diff --git a/.changeset/lucky-panthers-chew.md b/.changeset/lucky-panthers-chew.md
new file mode 100644
index 0000000000..9bd08df3e6
--- /dev/null
+++ b/.changeset/lucky-panthers-chew.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+chore: internal compiler refactoring
diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index d797703e92..2a4241a338 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -1,44 +1,171 @@
-/** @import { ArrowFunctionExpression, CallExpression, Expression, FunctionDeclaration, FunctionExpression, Identifier, LabeledStatement, Literal, Node, Program, Super } from 'estree' */
-/** @import { Attribute, BindDirective, Binding, DelegatedEvent, RegularElement, Root, Script, SvelteNode, Text, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */
-/** @import { AnalysisState, Context, LegacyAnalysisState, Visitors } from './types' */
+/** @import { Node, Program } from 'estree' */
+/** @import { Root, Script, SvelteNode, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */
+/** @import { AnalysisState, Visitors } from './types' */
 /** @import { Analysis, ComponentAnalysis, Js, ReactiveStatement, Template } from '../types' */
-import is_reference from 'is-reference';
 import { walk } from 'zimmerframe';
 import * as e from '../../errors.js';
 import * as w from '../../warnings.js';
-import {
-	extract_identifiers,
-	extract_all_identifiers_from_expression,
-	extract_paths,
-	is_event_attribute,
-	is_text_attribute,
-	object,
-	unwrap_optional,
-	get_attribute_expression,
-	get_attribute_chunks
-} from '../../utils/ast.js';
+import { is_text_attribute } from '../../utils/ast.js';
 import * as b from '../../utils/builders.js';
-import { MathMLElements, ReservedKeywords, Runes, SVGElements } from '../constants.js';
-import { Scope, ScopeRoot, create_scopes, get_rune, set_scope } from '../scope.js';
-import { merge } from '../visitors.js';
-import { validation_legacy, validation_runes, validation_runes_js } from './validation.js';
+import { ReservedKeywords, Runes } from '../constants.js';
+import { Scope, ScopeRoot, create_scopes, get_rune } from '../scope.js';
 import check_graph_for_cycles from './utils/check_graph_for_cycles.js';
-import { regex_starts_with_newline } from '../patterns.js';
-import { create_attribute, is_element_node } from '../nodes.js';
-import {
-	DelegatedEvents,
-	is_capture_event,
-	namespace_mathml,
-	namespace_svg
-} from '../../../constants.js';
-import { should_proxy_or_freeze } from '../3-transform/client/utils.js';
+import { create_attribute } from '../nodes.js';
 import { analyze_css } from './css/css-analyze.js';
 import { prune } from './css/css-prune.js';
 import { hash } from '../../../utils.js';
 import { warn_unused } from './css/css-warn.js';
 import { extract_svelte_ignore } from '../../utils/extract_svelte_ignore.js';
 import { ignore_map, ignore_stack, pop_ignore, push_ignore } from '../../state.js';
-import { equal } from '../../utils/assert.js';
+import { ArrowFunctionExpression } from './visitors/ArrowFunctionExpression.js';
+import { AssignmentExpression } from './visitors/AssignmentExpression.js';
+import { Attribute } from './visitors/Attribute.js';
+import { AwaitBlock } from './visitors/AwaitBlock.js';
+import { BindDirective } from './visitors/BindDirective.js';
+import { CallExpression } from './visitors/CallExpression.js';
+import { ClassBody } from './visitors/ClassBody.js';
+import { ClassDeclaration } from './visitors/ClassDeclaration.js';
+import { ClassDirective } from './visitors/ClassDirective.js';
+import { Component } from './visitors/Component.js';
+import { ConstTag } from './visitors/ConstTag.js';
+import { DebugTag } from './visitors/DebugTag.js';
+import { EachBlock } from './visitors/EachBlock.js';
+import { ExportDefaultDeclaration } from './visitors/ExportDefaultDeclaration.js';
+import { ExportNamedDeclaration } from './visitors/ExportNamedDeclaration.js';
+import { ExportSpecifier } from './visitors/ExportSpecifier.js';
+import { ExpressionStatement } from './visitors/ExpressionStatement.js';
+import { ExpressionTag } from './visitors/ExpressionTag.js';
+import { FunctionDeclaration } from './visitors/FunctionDeclaration.js';
+import { FunctionExpression } from './visitors/FunctionExpression.js';
+import { HtmlTag } from './visitors/HtmlTag.js';
+import { Identifier } from './visitors/Identifier.js';
+import { IfBlock } from './visitors/IfBlock.js';
+import { ImportDeclaration } from './visitors/ImportDeclaration.js';
+import { KeyBlock } from './visitors/KeyBlock.js';
+import { LabeledStatement } from './visitors/LabeledStatement.js';
+import { LetDirective } from './visitors/LetDirective.js';
+import { MemberExpression } from './visitors/MemberExpression.js';
+import { NewExpression } from './visitors/NewExpression.js';
+import { OnDirective } from './visitors/OnDirective.js';
+import { RegularElement } from './visitors/RegularElement.js';
+import { RenderTag } from './visitors/RenderTag.js';
+import { SlotElement } from './visitors/SlotElement.js';
+import { SnippetBlock } from './visitors/SnippetBlock.js';
+import { SpreadAttribute } from './visitors/SpreadAttribute.js';
+import { StyleDirective } from './visitors/StyleDirective.js';
+import { SvelteComponent } from './visitors/SvelteComponent.js';
+import { SvelteElement } from './visitors/SvelteElement.js';
+import { SvelteFragment } from './visitors/SvelteFragment.js';
+import { SvelteHead } from './visitors/SvelteHead.js';
+import { SvelteSelf } from './visitors/SvelteSelf.js';
+import { Text } from './visitors/Text.js';
+import { TitleElement } from './visitors/TitleElement.js';
+import { UpdateExpression } from './visitors/UpdateExpression.js';
+import { VariableDeclarator } from './visitors/VariableDeclarator.js';
+
+/**
+ * @type {Visitors}
+ */
+const visitors = {
+	_(node, { state, next, path }) {
+		const parent = path.at(-1);
+
+		/** @type {string[]} */
+		const ignores = [];
+
+		if (parent?.type === 'Fragment' && node.type !== 'Comment' && node.type !== 'Text') {
+			const idx = parent.nodes.indexOf(/** @type {any} */ (node));
+
+			for (let i = idx - 1; i >= 0; i--) {
+				const prev = parent.nodes[i];
+
+				if (prev.type === 'Comment') {
+					ignores.push(
+						...extract_svelte_ignore(
+							prev.start + 4 /* '<!--'.length */,
+							prev.data,
+							state.analysis.runes
+						)
+					);
+				} else if (prev.type !== 'Text') {
+					break;
+				}
+			}
+		} else {
+			const comments = /** @type {any} */ (node).leadingComments;
+
+			if (comments) {
+				for (const comment of comments) {
+					ignores.push(
+						...extract_svelte_ignore(
+							comment.start + 2 /* '//'.length */,
+							comment.value,
+							state.analysis.runes
+						)
+					);
+				}
+			}
+		}
+
+		if (ignores.length > 0) {
+			push_ignore(ignores);
+		}
+
+		ignore_map.set(node, structuredClone(ignore_stack));
+
+		const scope = state.scopes.get(node);
+		next(scope !== undefined && scope !== state.scope ? { ...state, scope } : state);
+
+		if (ignores.length > 0) {
+			pop_ignore();
+		}
+	},
+	ArrowFunctionExpression,
+	AssignmentExpression,
+	Attribute,
+	AwaitBlock,
+	BindDirective,
+	CallExpression,
+	ClassBody,
+	ClassDeclaration,
+	ClassDirective,
+	Component,
+	ConstTag,
+	DebugTag,
+	EachBlock,
+	ExportDefaultDeclaration,
+	ExportNamedDeclaration,
+	ExportSpecifier,
+	ExpressionStatement,
+	ExpressionTag,
+	FunctionDeclaration,
+	FunctionExpression,
+	HtmlTag,
+	Identifier,
+	IfBlock,
+	ImportDeclaration,
+	KeyBlock,
+	LabeledStatement,
+	LetDirective,
+	MemberExpression,
+	NewExpression,
+	OnDirective,
+	RegularElement,
+	RenderTag,
+	SlotElement,
+	SnippetBlock,
+	SpreadAttribute,
+	StyleDirective,
+	SvelteHead,
+	SvelteElement,
+	SvelteFragment,
+	SvelteComponent,
+	SvelteSelf,
+	Text,
+	TitleElement,
+	UpdateExpression,
+	VariableDeclarator
+};
 
 /**
  * @param {Script | null} script
@@ -76,157 +203,6 @@ function get_component_name(filename) {
 	return name[0].toUpperCase() + name.slice(1);
 }
 
-/**
- * Checks if given event attribute can be delegated/hoisted and returns the corresponding info if so
- * @param {string} event_name
- * @param {Expression | null} handler
- * @param {Context} context
- * @returns {null | DelegatedEvent}
- */
-function get_delegated_event(event_name, handler, context) {
-	// Handle delegated event handlers. Bail-out if not a delegated event.
-	if (!handler || !DelegatedEvents.includes(event_name)) {
-		return null;
-	}
-
-	// If we are not working with a RegularElement, then bail-out.
-	const element = context.path.at(-1);
-	if (element?.type !== 'RegularElement') {
-		return null;
-	}
-
-	/** @type {DelegatedEvent} */
-	const non_hoistable = { type: 'non-hoistable' };
-	/** @type {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression | null} */
-	let target_function = null;
-	let binding = null;
-
-	if (element.metadata.has_spread) {
-		// event attribute becomes part of the dynamic spread array
-		return non_hoistable;
-	}
-
-	if (handler.type === 'ArrowFunctionExpression' || handler.type === 'FunctionExpression') {
-		target_function = handler;
-	} else if (handler.type === 'Identifier') {
-		binding = context.state.scope.get(handler.name);
-
-		if (context.state.analysis.module.scope.references.has(handler.name)) {
-			// If a binding with the same name is referenced in the module scope (even if not declared there), bail-out
-			return non_hoistable;
-		}
-
-		if (binding != null) {
-			for (const { path } of binding.references) {
-				const parent = path.at(-1);
-				if (parent == null) return non_hoistable;
-
-				const grandparent = path.at(-2);
-
-				/** @type {RegularElement | null} */
-				let element = null;
-				/** @type {string | null} */
-				let event_name = null;
-				if (parent.type === 'OnDirective') {
-					element = /** @type {RegularElement} */ (grandparent);
-					event_name = parent.name;
-				} else if (
-					parent.type === 'ExpressionTag' &&
-					grandparent?.type === 'Attribute' &&
-					is_event_attribute(grandparent)
-				) {
-					element = /** @type {RegularElement} */ (path.at(-3));
-					const attribute = /** @type {Attribute} */ (grandparent);
-					event_name = get_attribute_event_name(attribute.name);
-				}
-
-				if (element && event_name) {
-					if (
-						element.type !== 'RegularElement' ||
-						determine_element_spread(element).metadata.has_spread ||
-						!DelegatedEvents.includes(event_name)
-					) {
-						return non_hoistable;
-					}
-				} else if (parent.type !== 'FunctionDeclaration' && parent.type !== 'VariableDeclarator') {
-					return non_hoistable;
-				}
-			}
-		}
-
-		// If the binding is exported, bail-out
-		if (context.state.analysis.exports.find((node) => node.name === handler.name)) {
-			return non_hoistable;
-		}
-
-		if (binding !== null && binding.initial !== null && !binding.mutated && !binding.is_called) {
-			const binding_type = binding.initial.type;
-
-			if (
-				binding_type === 'ArrowFunctionExpression' ||
-				binding_type === 'FunctionDeclaration' ||
-				binding_type === 'FunctionExpression'
-			) {
-				target_function = binding.initial;
-			}
-		}
-	}
-
-	// If we can't find a function, bail-out
-	if (target_function == null) return non_hoistable;
-	// If the function is marked as non-hoistable, bail-out
-	if (target_function.metadata.hoistable === 'impossible') return non_hoistable;
-	// If the function has more than one arg, then bail-out
-	if (target_function.params.length > 1) return non_hoistable;
-
-	const visited_references = new Set();
-	const scope = target_function.metadata.scope;
-	for (const [reference] of scope.references) {
-		// Bail-out if the arguments keyword is used
-		if (reference === 'arguments') return non_hoistable;
-		// Bail-out if references a store subscription
-		if (scope.get(`$${reference}`)?.kind === 'store_sub') return non_hoistable;
-
-		const binding = scope.get(reference);
-		const local_binding = context.state.scope.get(reference);
-
-		// If we are referencing a binding that is shadowed in another scope then bail out.
-		if (local_binding !== null && binding !== null && local_binding.node !== binding.node) {
-			return non_hoistable;
-		}
-
-		// If we have multiple references to the same store using $ prefix, bail out.
-		if (
-			binding !== null &&
-			binding.kind === 'store_sub' &&
-			visited_references.has(reference.slice(1))
-		) {
-			return non_hoistable;
-		}
-
-		// If we reference the index within an each block, then bail-out.
-		if (binding !== null && binding.initial?.type === 'EachBlock') return non_hoistable;
-
-		if (
-			binding !== null &&
-			// Bail-out if the the binding is a rest param
-			(binding.declaration_kind === 'rest_param' ||
-				// Bail-out if we reference anything from the EachBlock (for now) that mutates in non-runes mode,
-				(((!context.state.analysis.runes && binding.kind === 'each') ||
-					// or any normal not reactive bindings that are mutated.
-					binding.kind === 'normal' ||
-					// or any reactive imports (those are rewritten) (can only happen in legacy mode)
-					binding.kind === 'legacy_reactive_import') &&
-					binding.mutated))
-		) {
-			return non_hoistable;
-		}
-		visited_references.add(reference);
-	}
-
-	return { type: 'hoistable', function: target_function };
-}
-
 /**
  * @param {Program} ast
  * @param {ValidatedModuleCompileOptions} options
@@ -244,9 +220,13 @@ export function analyze_module(ast, options) {
 
 	walk(
 		/** @type {Node} */ (ast),
-		{ scope, analysis: { runes: true } },
-		// @ts-expect-error TODO clean this mess up
-		merge(set_scope(scopes), validation_runes_js, runes_scope_js_tweaker)
+		{
+			scope,
+			scopes,
+			// @ts-expect-error TODO
+			analysis: { runes: true }
+		},
+		visitors
 	);
 
 	return {
@@ -441,6 +421,7 @@ export function analyze_component(root, source, options) {
 			/** @type {AnalysisState} */
 			const state = {
 				scope,
+				scopes,
 				analysis,
 				options,
 				ast_type: ast === instance.ast ? 'instance' : ast === template.ast ? 'template' : 'module',
@@ -450,14 +431,13 @@ export function analyze_component(root, source, options) {
 				expression: null,
 				render_tag: null,
 				private_derived_state: [],
-				function_depth: scope.function_depth
+				function_depth: scope.function_depth,
+				instance_scope: instance.scope,
+				reactive_statement: null,
+				reactive_statements: new Map()
 			};
 
-			walk(
-				/** @type {SvelteNode} */ (ast),
-				state,
-				merge(set_scope(scopes), validation_runes, runes_scope_tweaker, common_visitors)
-			);
+			walk(/** @type {SvelteNode} */ (ast), state, visitors);
 		}
 
 		// warn on any nonstate declarations that are a) reassigned and b) referenced in the template
@@ -478,7 +458,7 @@ export function analyze_component(root, source, options) {
 							// bind:this doesn't need to be a state reference if it will never change
 							if (
 								type === 'BindDirective' &&
-								/** @type {BindDirective} */ (path[i]).name === 'this'
+								/** @type {import('#compiler').BindDirective} */ (path[i]).name === 'this'
 							) {
 								for (let j = i - 1; j >= 0; j -= 1) {
 									const type = path[j].type;
@@ -507,9 +487,10 @@ export function analyze_component(root, source, options) {
 		instance.scope.declare(b.id('$$restProps'), 'rest_prop', 'synthetic');
 
 		for (const { ast, scope, scopes } of [module, instance, template]) {
-			/** @type {LegacyAnalysisState} */
+			/** @type {AnalysisState} */
 			const state = {
 				scope,
+				scopes,
 				analysis,
 				options,
 				parent_element: null,
@@ -525,12 +506,7 @@ export function analyze_component(root, source, options) {
 				function_depth: scope.function_depth
 			};
 
-			walk(
-				/** @type {SvelteNode} */ (ast),
-				state,
-				// @ts-expect-error TODO
-				merge(set_scope(scopes), validation_legacy, legacy_scope_tweaker, common_visitors)
-			);
+			walk(/** @type {SvelteNode} */ (ast), state, visitors);
 		}
 
 		for (const [name, binding] of instance.scope.declarations) {
@@ -587,7 +563,7 @@ export function analyze_component(root, source, options) {
 				// TODO this happens during the analysis phase, which shouldn't know anything about client vs server
 				if (element.type === 'SvelteElement' && options.generate === 'client') continue;
 
-				/** @type {Attribute | undefined} */
+				/** @type {import('#compiler').Attribute | undefined} */
 				let class_attribute = undefined;
 
 				for (const attribute of element.attributes) {
@@ -606,7 +582,7 @@ export function analyze_component(root, source, options) {
 					if (is_text_attribute(class_attribute)) {
 						class_attribute.value[0].data += ` ${analysis.css.hash}`;
 					} else {
-						/** @type {Text} */
+						/** @type {import('#compiler').Text} */
 						const css_text = {
 							type: 'Text',
 							data: ` ${analysis.css.hash}`,
@@ -646,959 +622,11 @@ export function analyze_component(root, source, options) {
 	return analysis;
 }
 
-/** @type {Visitors<LegacyAnalysisState>} */
-const legacy_scope_tweaker = {
-	LabeledStatement(node, { next, path, state }) {
-		if (
-			state.ast_type !== 'instance' ||
-			node.label.name !== '$' ||
-			/** @type {SvelteNode} */ (path.at(-1)).type !== 'Program'
-		) {
-			return next();
-		}
-
-		// Find all dependencies of this `$: {...}` statement
-		/** @type {ReactiveStatement} */
-		const reactive_statement = {
-			assignments: new Set(),
-			dependencies: []
-		};
-
-		next({ ...state, reactive_statement, function_depth: state.scope.function_depth + 1 });
-
-		// Every referenced binding becomes a dependency, unless it's on
-		// the left-hand side of an `=` assignment
-		for (const [name, nodes] of state.scope.references) {
-			const binding = state.scope.get(name);
-			if (binding === null) continue;
-
-			for (const { node, path } of nodes) {
-				/** @type {Expression} */
-				let left = node;
-
-				let i = path.length - 1;
-				let parent = /** @type {Expression} */ (path.at(i));
-				while (parent.type === 'MemberExpression') {
-					left = parent;
-					parent = /** @type {Expression} */ (path.at(--i));
-				}
-
-				if (
-					parent.type === 'AssignmentExpression' &&
-					parent.operator === '=' &&
-					parent.left === left
-				) {
-					continue;
-				}
-
-				reactive_statement.dependencies.push(binding);
-				break;
-			}
-		}
-
-		state.reactive_statements.set(node, reactive_statement);
-
-		// Ideally this would be in the validation file, but that isn't possible because this visitor
-		// calls "next" before setting the reactive statements.
-		if (
-			reactive_statement.dependencies.length &&
-			reactive_statement.dependencies.every(
-				(d) => d.scope === state.analysis.module.scope && d.declaration_kind !== 'const'
-			)
-		) {
-			w.reactive_declaration_module_script(node);
-		}
-
-		if (
-			node.body.type === 'ExpressionStatement' &&
-			node.body.expression.type === 'AssignmentExpression'
-		) {
-			let ids = extract_identifiers(node.body.expression.left);
-			if (node.body.expression.left.type === 'MemberExpression') {
-				const id = object(node.body.expression.left);
-				if (id !== null) {
-					ids = [id];
-				}
-			}
-
-			for (const id of ids) {
-				const binding = state.scope.get(id.name);
-				if (binding?.kind === 'legacy_reactive') {
-					// TODO does this include `let double; $: double = x * 2`?
-					binding.legacy_dependencies = Array.from(reactive_statement.dependencies);
-				}
-			}
-		}
-	},
-	AssignmentExpression(node, { state, next }) {
-		if (state.reactive_statement) {
-			const id = node.left.type === 'MemberExpression' ? object(node.left) : node.left;
-			if (id !== null) {
-				for (const id of extract_identifiers(node.left)) {
-					const binding = state.scope.get(id.name);
-
-					if (binding) {
-						state.reactive_statement.assignments.add(binding);
-					}
-				}
-			}
-		}
-
-		next();
-	},
-	UpdateExpression(node, { state, next }) {
-		if (state.reactive_statement) {
-			const id = node.argument.type === 'MemberExpression' ? object(node.argument) : node.argument;
-			if (id?.type === 'Identifier') {
-				const binding = state.scope.get(id.name);
-
-				if (binding) {
-					state.reactive_statement.assignments.add(binding);
-				}
-			}
-		}
-
-		next();
-	},
-	Identifier(node, { state, path }) {
-		const parent = /** @type {Node} */ (path.at(-1));
-		if (is_reference(node, parent)) {
-			if (node.name === '$$props') {
-				state.analysis.uses_props = true;
-			}
-
-			if (node.name === '$$restProps') {
-				state.analysis.uses_rest_props = true;
-			}
-
-			if (node.name === '$$slots') {
-				state.analysis.uses_slots = true;
-			}
-
-			let binding = state.scope.get(node.name);
-
-			if (binding?.kind === 'store_sub') {
-				// get the underlying store to mark it as reactive in case it's mutated
-				binding = state.scope.get(node.name.slice(1));
-			}
-
-			if (
-				binding?.kind === 'normal' &&
-				((binding.scope === state.instance_scope && binding.declaration_kind !== 'function') ||
-					binding.declaration_kind === 'import')
-			) {
-				if (binding.declaration_kind === 'import') {
-					if (
-						binding.mutated &&
-						// TODO could be more fine-grained - not every mention in the template implies a state binding
-						(state.reactive_statement || state.ast_type === 'template') &&
-						parent.type === 'MemberExpression'
-					) {
-						binding.kind = 'legacy_reactive_import';
-					}
-				} else if (
-					binding.mutated &&
-					// TODO could be more fine-grained - not every mention in the template implies a state binding
-					(state.reactive_statement || state.ast_type === 'template')
-				) {
-					binding.kind = 'state';
-				} else if (
-					state.reactive_statement &&
-					parent.type === 'AssignmentExpression' &&
-					parent.left === binding.node
-				) {
-					binding.kind = 'derived';
-				}
-			} else if (binding?.kind === 'each' && binding.mutated) {
-				// Ensure that the array is marked as reactive even when only its entries are mutated
-				let i = path.length;
-				while (i--) {
-					const ancestor = path[i];
-					if (
-						ancestor.type === 'EachBlock' &&
-						state.analysis.template.scopes.get(ancestor)?.declarations.get(node.name) === binding
-					) {
-						for (const binding of ancestor.metadata.references) {
-							if (binding.kind === 'normal') {
-								binding.kind = 'state';
-							}
-						}
-						break;
-					}
-				}
-			}
-		}
-	},
-	ExportNamedDeclaration(node, { next, state }) {
-		if (state.ast_type !== 'instance') {
-			return next();
-		}
-
-		state.analysis.needs_props = true;
-
-		if (!node.declaration) {
-			for (const specifier of node.specifiers) {
-				const binding = /** @type {Binding} */ (state.scope.get(specifier.local.name));
-				if (
-					binding !== null &&
-					(binding.kind === 'state' ||
-						binding.kind === 'frozen_state' ||
-						(binding.kind === 'normal' &&
-							(binding.declaration_kind === 'let' || binding.declaration_kind === 'var')))
-				) {
-					binding.kind = 'bindable_prop';
-					if (specifier.exported.name !== specifier.local.name) {
-						binding.prop_alias = specifier.exported.name;
-					}
-				} else {
-					state.analysis.exports.push({
-						name: specifier.local.name,
-						alias: specifier.exported.name
-					});
-				}
-			}
-			return next();
-		}
-
-		if (
-			node.declaration.type === 'FunctionDeclaration' ||
-			node.declaration.type === 'ClassDeclaration'
-		) {
-			state.analysis.exports.push({
-				name: /** @type {Identifier} */ (node.declaration.id).name,
-				alias: null
-			});
-			return next();
-		}
-
-		if (node.declaration.type === 'VariableDeclaration') {
-			if (node.declaration.kind === 'const') {
-				for (const declarator of node.declaration.declarations) {
-					for (const node of extract_identifiers(declarator.id)) {
-						state.analysis.exports.push({ name: node.name, alias: null });
-					}
-				}
-				return next();
-			}
-
-			for (const declarator of node.declaration.declarations) {
-				for (const id of extract_identifiers(declarator.id)) {
-					const binding = /** @type {Binding} */ (state.scope.get(id.name));
-					binding.kind = 'bindable_prop';
-				}
-			}
-		}
-	},
-	StyleDirective(node, { state }) {
-		// the case for node.value different from true is already covered by the Identifier visitor
-		if (node.value === true) {
-			// get the binding for node.name and change the binding to state
-			let binding = state.scope.get(node.name);
-			if (binding?.mutated && binding.kind === 'normal') {
-				binding.kind = 'state';
-			}
-		}
-	}
-};
-
-/** @type {Visitors} */
-const runes_scope_js_tweaker = {
-	VariableDeclarator(node, { state }) {
-		if (node.init?.type !== 'CallExpression') return;
-		const rune = get_rune(node.init, state.scope);
-		if (rune === null) return;
-
-		const callee = node.init.callee;
-		if (callee.type !== 'Identifier' && callee.type !== 'MemberExpression') return;
-
-		if (
-			rune !== '$state' &&
-			rune !== '$state.frozen' &&
-			rune !== '$derived' &&
-			rune !== '$derived.by'
-		)
-			return;
-
-		for (const path of extract_paths(node.id)) {
-			// @ts-ignore this fails in CI for some insane reason
-			const binding = /** @type {Binding} */ (state.scope.get(path.node.name));
-			binding.kind =
-				rune === '$state' ? 'state' : rune === '$state.frozen' ? 'frozen_state' : 'derived';
-		}
-	}
-};
-
-/** @type {Visitors} */
-const runes_scope_tweaker = {
-	CallExpression(node, { state, next }) {
-		const rune = get_rune(node, state.scope);
-
-		// `$inspect(foo)` should not trigger the `static-state-reference` warning
-		if (rune === '$inspect') {
-			next({ ...state, function_depth: state.function_depth + 1 });
-		}
-	},
-	VariableDeclarator(node, { state }) {
-		const init = node.init;
-		if (!init || init.type !== 'CallExpression') return;
-		const rune = get_rune(init, state.scope);
-		if (rune === null) return;
-
-		const callee = init.callee;
-		if (callee.type !== 'Identifier' && callee.type !== 'MemberExpression') return;
-
-		if (
-			rune !== '$state' &&
-			rune !== '$state.frozen' &&
-			rune !== '$derived' &&
-			rune !== '$derived.by' &&
-			rune !== '$props'
-		)
-			return;
-
-		for (const path of extract_paths(node.id)) {
-			// @ts-ignore this fails in CI for some insane reason
-			const binding = /** @type {Binding} */ (state.scope.get(path.node.name));
-			binding.kind =
-				rune === '$state'
-					? 'state'
-					: rune === '$state.frozen'
-						? 'frozen_state'
-						: rune === '$derived' || rune === '$derived.by'
-							? 'derived'
-							: path.is_rest
-								? 'rest_prop'
-								: 'prop';
-		}
-
-		if (rune === '$props') {
-			state.analysis.needs_props = true;
-
-			if (node.id.type === 'Identifier') {
-				const binding = /** @type {Binding} */ (state.scope.get(node.id.name));
-				binding.initial = null; // else would be $props()
-				binding.kind = 'rest_prop';
-			} else {
-				equal(node.id.type, 'ObjectPattern');
-
-				for (const property of node.id.properties) {
-					if (property.type !== 'Property') continue;
-
-					const name =
-						property.value.type === 'AssignmentPattern'
-							? /** @type {Identifier} */ (property.value.left).name
-							: /** @type {Identifier} */ (property.value).name;
-					const alias =
-						property.key.type === 'Identifier'
-							? property.key.name
-							: String(/** @type {Literal} */ (property.key).value);
-					let initial = property.value.type === 'AssignmentPattern' ? property.value.right : null;
-
-					const binding = /** @type {Binding} */ (state.scope.get(name));
-					binding.prop_alias = alias;
-
-					// rewire initial from $props() to the actual initial value, stripping $bindable() if necessary
-					if (
-						initial?.type === 'CallExpression' &&
-						initial.callee.type === 'Identifier' &&
-						initial.callee.name === '$bindable'
-					) {
-						binding.initial = /** @type {Expression | null} */ (initial.arguments[0] ?? null);
-						binding.kind = 'bindable_prop';
-					} else {
-						binding.initial = initial;
-					}
-				}
-			}
-		}
-	},
-	ExportSpecifier(node, { state }) {
-		if (state.ast_type !== 'instance') return;
-
-		state.analysis.exports.push({
-			name: node.local.name,
-			alias: node.exported.name
-		});
-
-		const binding = state.scope.get(node.local.name);
-		if (binding) binding.reassigned = true;
-	},
-	ExportNamedDeclaration(node, { next, state }) {
-		if (!node.declaration || state.ast_type !== 'instance') {
-			return next();
-		}
-
-		if (
-			node.declaration.type === 'FunctionDeclaration' ||
-			node.declaration.type === 'ClassDeclaration'
-		) {
-			state.analysis.exports.push({
-				name: /** @type {Identifier} */ (node.declaration.id).name,
-				alias: null
-			});
-			return next();
-		}
-
-		if (node.declaration.type === 'VariableDeclaration' && node.declaration.kind === 'const') {
-			for (const declarator of node.declaration.declarations) {
-				for (const node of extract_identifiers(declarator.id)) {
-					state.analysis.exports.push({ name: node.name, alias: null });
-				}
-			}
-		}
-	}
-};
-
-/**
- * @param {CallExpression} node
- * @param {Context} context
- * @returns {boolean}
- */
-function is_known_safe_call(node, context) {
-	const callee = node.callee;
-
-	// String / Number / BigInt / Boolean casting calls
-	if (callee.type === 'Identifier') {
-		const name = callee.name;
-		const binding = context.state.scope.get(name);
-		if (
-			binding === null &&
-			(name === 'BigInt' || name === 'String' || name === 'Number' || name === 'Boolean')
-		) {
-			return true;
-		}
-	}
-
-	// TODO add more cases
-
-	return false;
-}
-
-/**
- * @param {ArrowFunctionExpression | FunctionExpression | FunctionDeclaration} node
- * @param {Context} context
- */
-const function_visitor = (node, context) => {
-	// TODO retire this in favour of a more general solution based on bindings
-	node.metadata = {
-		// module context -> already hoisted
-		hoistable: context.state.ast_type === 'module' ? 'impossible' : false,
-		hoistable_params: [],
-		scope: context.state.scope
-	};
-
-	context.next({
-		...context.state,
-		function_depth: context.state.function_depth + 1
-	});
-};
-
-/**
- * A 'safe' identifier means that the `foo` in `foo.bar` or `foo()` will not
- * call functions that require component context to exist
- * @param {Expression | Super} expression
- * @param {Scope} scope
- */
-function is_safe_identifier(expression, scope) {
-	let node = expression;
-	while (node.type === 'MemberExpression') node = node.object;
-
-	if (node.type !== 'Identifier') return false;
-
-	const binding = scope.get(node.name);
-	if (!binding) return true;
-
-	if (binding.kind === 'store_sub') {
-		return is_safe_identifier({ name: node.name.slice(1), type: 'Identifier' }, scope);
-	}
-
-	return (
-		binding.declaration_kind !== 'import' &&
-		binding.kind !== 'prop' &&
-		binding.kind !== 'bindable_prop' &&
-		binding.kind !== 'rest_prop'
-	);
-}
-
-/** @type {Visitors} */
-const common_visitors = {
-	_(node, { state, next, path }) {
-		ignore_map.set(node, structuredClone(ignore_stack));
-		const parent = path.at(-1);
-		if (parent?.type === 'Fragment' && node.type !== 'Comment' && node.type !== 'Text') {
-			const idx = parent.nodes.indexOf(/** @type {any} */ (node));
-			/** @type {string[]} */
-			const ignores = [];
-			for (let i = idx - 1; i >= 0; i--) {
-				const prev = parent.nodes[i];
-				if (prev.type === 'Comment') {
-					ignores.push(
-						...extract_svelte_ignore(
-							prev.start + 4 /* '<!--'.length */,
-							prev.data,
-							state.analysis.runes
-						)
-					);
-				} else if (prev.type !== 'Text') {
-					break;
-				}
-			}
-
-			if (ignores.length > 0) {
-				push_ignore(ignores);
-				ignore_map.set(node, structuredClone(ignore_stack));
-				next();
-				pop_ignore();
-			}
-		} else {
-			const comments = /** @type {any} */ (node).leadingComments;
-			if (comments) {
-				/** @type {string[]} */
-				const ignores = [];
-				for (const comment of comments) {
-					ignores.push(
-						...extract_svelte_ignore(
-							comment.start + 2 /* '//'.length */,
-							comment.value,
-							state.analysis.runes
-						)
-					);
-				}
-				if (ignores.length > 0) {
-					push_ignore(ignores);
-					ignore_map.set(node, structuredClone(ignore_stack));
-					next();
-					pop_ignore();
-				}
-			}
-		}
-	},
-	Attribute(node, context) {
-		if (node.value === true) return;
-
-		context.next();
-
-		for (const chunk of get_attribute_chunks(node.value)) {
-			if (chunk.type !== 'ExpressionTag') continue;
-
-			if (
-				chunk.expression.type === 'FunctionExpression' ||
-				chunk.expression.type === 'ArrowFunctionExpression'
-			) {
-				continue;
-			}
-
-			node.metadata.expression.has_state ||= chunk.metadata.expression.has_state;
-			node.metadata.expression.has_call ||= chunk.metadata.expression.has_call;
-		}
-
-		if (is_event_attribute(node)) {
-			const parent = context.path.at(-1);
-			if (parent?.type === 'RegularElement' || parent?.type === 'SvelteElement') {
-				context.state.analysis.uses_event_attributes = true;
-			}
-
-			const expression = get_attribute_expression(node);
-			const delegated_event = get_delegated_event(node.name.slice(2), expression, context);
-
-			if (delegated_event !== null) {
-				if (delegated_event.type === 'hoistable') {
-					delegated_event.function.metadata.hoistable = true;
-				}
-				node.metadata.delegated = delegated_event;
-			}
-		}
-	},
-	ClassDirective(node, context) {
-		context.next({ ...context.state, expression: node.metadata.expression });
-	},
-	SpreadAttribute(node, context) {
-		context.next({ ...context.state, expression: node.metadata.expression });
-	},
-	SlotElement(node, context) {
-		let name = 'default';
-		for (const attr of node.attributes) {
-			if (attr.type === 'Attribute' && attr.name === 'name' && is_text_attribute(attr)) {
-				name = attr.value[0].data;
-				break;
-			}
-		}
-		context.state.analysis.slot_names.set(name, node);
-	},
-	StyleDirective(node, context) {
-		if (node.value === true) {
-			const binding = context.state.scope.get(node.name);
-			if (binding?.kind !== 'normal') {
-				node.metadata.expression.has_state = true;
-			}
-		} else {
-			context.next();
-
-			for (const chunk of get_attribute_chunks(node.value)) {
-				if (chunk.type !== 'ExpressionTag') continue;
-
-				node.metadata.expression.has_state ||= chunk.metadata.expression.has_state;
-				node.metadata.expression.has_call ||= chunk.metadata.expression.has_call;
-			}
-		}
-	},
-	ExpressionTag(node, context) {
-		context.next({ ...context.state, expression: node.metadata.expression });
-	},
-	Identifier(node, context) {
-		const parent = /** @type {Node} */ (context.path.at(-1));
-		if (!is_reference(node, parent)) return;
-
-		if (node.name === '$$slots') {
-			context.state.analysis.uses_slots = true;
-			return;
-		}
-
-		// If we are using arguments outside of a function, then throw an error
-		if (
-			node.name === 'arguments' &&
-			context.path.every((n) => n.type !== 'FunctionDeclaration' && n.type !== 'FunctionExpression')
-		) {
-			e.invalid_arguments_usage(node);
-		}
-
-		const binding = context.state.scope.get(node.name);
-
-		if (binding && context.state.expression) {
-			context.state.expression.dependencies.add(binding);
-
-			if (binding.kind !== 'normal') {
-				context.state.expression.has_state = true;
-			}
-		}
-
-		// if no binding, means some global variable
-		if (binding && binding.kind !== 'normal') {
-			if (context.state.expression) {
-				context.state.expression.has_state = true;
-			}
-
-			// TODO it would be better to just bail out when we hit the ExportSpecifier node but that's
-			// not currently possibly because of our visitor merging, which I desperately want to nuke
-			const is_export_specifier =
-				/** @type {SvelteNode} */ (context.path.at(-1)).type === 'ExportSpecifier';
-
-			if (
-				context.state.analysis.runes &&
-				node !== binding.node &&
-				context.state.function_depth === binding.scope.function_depth &&
-				// If we have $state that can be proxied or frozen and isn't re-assigned, then that means
-				// it's likely not using a primitive value and thus this warning isn't that helpful.
-				((binding.kind === 'state' &&
-					(binding.reassigned ||
-						(binding.initial?.type === 'CallExpression' &&
-							binding.initial.arguments.length === 1 &&
-							binding.initial.arguments[0].type !== 'SpreadElement' &&
-							!should_proxy_or_freeze(binding.initial.arguments[0], context.state.scope)))) ||
-					binding.kind === 'frozen_state' ||
-					binding.kind === 'derived') &&
-				!is_export_specifier &&
-				// We're only concerned with reads here
-				(parent.type !== 'AssignmentExpression' || parent.left !== node) &&
-				parent.type !== 'UpdateExpression'
-			) {
-				w.state_referenced_locally(node);
-			}
-		}
-	},
-	CallExpression(node, context) {
-		const { expression, render_tag } = context.state;
-
-		if (expression && !is_known_safe_call(node, context)) {
-			expression.has_call = true;
-			expression.has_state = true;
-		}
-
-		if (render_tag) {
-			// Find out which of the render tag arguments contains this call expression
-			const arg_idx = unwrap_optional(render_tag.expression).arguments.findIndex(
-				(arg) => arg === node || context.path.includes(arg)
-			);
-
-			// -1 if this is the call expression of the render tag itself
-			if (arg_idx !== -1) {
-				render_tag.metadata.args_with_call_expression.add(arg_idx);
-			}
-		}
-
-		const callee = node.callee;
-		const rune = get_rune(node, context.state.scope);
-
-		if (callee.type === 'Identifier') {
-			const binding = context.state.scope.get(callee.name);
-
-			if (binding !== null) {
-				binding.is_called = true;
-			}
-
-			if (rune === '$derived') {
-				// special case — `$derived(foo)` is treated as `$derived(() => foo)`
-				// for the purposes of identifying static state references
-				context.next({
-					...context.state,
-					function_depth: context.state.function_depth + 1
-				});
-
-				return;
-			}
-		}
-
-		if (rune === '$effect' || rune === '$effect.pre') {
-			// `$effect` needs context because Svelte needs to know whether it should re-run
-			// effects that invalidate themselves, and that's determined by whether we're in runes mode
-			context.state.analysis.needs_context = true;
-		} else if (rune === null) {
-			if (!is_safe_identifier(callee, context.state.scope)) {
-				context.state.analysis.needs_context = true;
-			}
-		}
-
-		context.next();
-	},
-	MemberExpression(node, context) {
-		if (context.state.expression) {
-			context.state.expression.has_state = true;
-		}
-
-		if (!is_safe_identifier(node, context.state.scope)) {
-			context.state.analysis.needs_context = true;
-		}
-
-		context.next();
-	},
-	OnDirective(node, { state, path, next }) {
-		const parent = path.at(-1);
-		if (parent?.type === 'SvelteElement' || parent?.type === 'RegularElement') {
-			state.analysis.event_directive_node ??= node;
-		}
-		next({ ...state, expression: node.metadata.expression });
-	},
-	BindDirective(node, context) {
-		let i = context.path.length;
-		while (i--) {
-			const parent = context.path[i];
-			if (
-				parent.type === 'Component' ||
-				parent.type === 'SvelteComponent' ||
-				parent.type === 'SvelteSelf'
-			) {
-				if (node.name !== 'this') {
-					context.state.analysis.uses_component_bindings = true;
-				}
-				break;
-			} else if (is_element_node(parent)) {
-				break;
-			}
-		}
-
-		if (node.name !== 'group') return;
-
-		// Traverse the path upwards and find all EachBlocks who are (indirectly) contributing to bind:group,
-		// i.e. one of their declarations is referenced in the binding. This allows group bindings to work
-		// correctly when referencing a variable declared in an EachBlock by using the index of the each block
-		// entries as keys.
-		i = context.path.length;
-		const each_blocks = [];
-		const [keypath, expression_ids] = extract_all_identifiers_from_expression(node.expression);
-		let ids = expression_ids;
-		while (i--) {
-			const parent = context.path[i];
-			if (parent.type === 'EachBlock') {
-				const references = ids.filter((id) => parent.metadata.declarations.has(id.name));
-				if (references.length > 0) {
-					parent.metadata.contains_group_binding = true;
-					for (const binding of parent.metadata.references) {
-						binding.mutated = true;
-					}
-					each_blocks.push(parent);
-					ids = ids.filter((id) => !references.includes(id));
-					ids.push(...extract_all_identifiers_from_expression(parent.expression)[1]);
-				}
-			}
-		}
-
-		// The identifiers that make up the binding expression form they key for the binding group.
-		// If the same identifiers in the same order are used in another bind:group, they will be in the same group.
-		// (there's an edge case where `bind:group={a[i]}` will be in a different group than `bind:group={a[j]}` even when i == j,
-		//  but this is a limitation of the current static analysis we do; it also never worked in Svelte 4)
-		const bindings = expression_ids.map((id) => context.state.scope.get(id.name));
-		let group_name;
-		outer: for (const [[key, b], group] of context.state.analysis.binding_groups) {
-			if (b.length !== bindings.length || key !== keypath) continue;
-			for (let i = 0; i < bindings.length; i++) {
-				if (bindings[i] !== b[i]) continue outer;
-			}
-			group_name = group;
-		}
-
-		if (!group_name) {
-			group_name = context.state.scope.root.unique('binding_group');
-			context.state.analysis.binding_groups.set([keypath, bindings], group_name);
-		}
-
-		node.metadata = {
-			binding_group_name: group_name,
-			parent_each_blocks: each_blocks
-		};
-	},
-	ArrowFunctionExpression: function_visitor,
-	FunctionExpression: function_visitor,
-	FunctionDeclaration: function_visitor,
-	RegularElement(node, context) {
-		if (context.state.options.namespace !== 'foreign') {
-			if (SVGElements.includes(node.name)) node.metadata.svg = true;
-			else if (MathMLElements.includes(node.name)) node.metadata.mathml = true;
-		}
-
-		determine_element_spread(node);
-
-		// Special case: Move the children of <textarea> into a value attribute if they are dynamic
-		if (
-			context.state.options.namespace !== 'foreign' &&
-			node.name === 'textarea' &&
-			node.fragment.nodes.length > 0
-		) {
-			if (node.fragment.nodes.length > 1 || node.fragment.nodes[0].type !== 'Text') {
-				const first = node.fragment.nodes[0];
-				if (first.type === 'Text') {
-					// The leading newline character needs to be stripped because of a qirk:
-					// It is ignored by browsers if the tag and its contents are set through
-					// innerHTML, but we're now setting it through the value property at which
-					// point it is _not_ ignored, so we need to strip it ourselves.
-					// see https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
-					// see https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element
-					first.data = first.data.replace(regex_starts_with_newline, '');
-					first.raw = first.raw.replace(regex_starts_with_newline, '');
-				}
-
-				node.attributes.push(
-					create_attribute(
-						'value',
-						/** @type {Text} */ (node.fragment.nodes.at(0)).start,
-						/** @type {Text} */ (node.fragment.nodes.at(-1)).end,
-						// @ts-ignore
-						node.fragment.nodes
-					)
-				);
-
-				node.fragment.nodes = [];
-			}
-		}
-
-		// Special case: single expression tag child of option element -> add "fake" attribute
-		// to ensure that value types are the same (else for example numbers would be strings)
-		if (
-			context.state.options.namespace !== 'foreign' &&
-			node.name === 'option' &&
-			node.fragment.nodes?.length === 1 &&
-			node.fragment.nodes[0].type === 'ExpressionTag' &&
-			!node.attributes.some(
-				(attribute) => attribute.type === 'Attribute' && attribute.name === 'value'
-			)
-		) {
-			const child = node.fragment.nodes[0];
-			node.attributes.push(create_attribute('value', child.start, child.end, [child]));
-		}
-
-		context.state.analysis.elements.push(node);
-	},
-	SvelteElement(node, context) {
-		context.state.analysis.elements.push(node);
-
-		for (const attribute of node.attributes) {
-			if (attribute.type === 'Attribute') {
-				if (attribute.name === 'xmlns' && is_text_attribute(attribute)) {
-					node.metadata.svg = attribute.value[0].data === namespace_svg;
-					node.metadata.mathml = attribute.value[0].data === namespace_mathml;
-					return;
-				}
-			}
-		}
-
-		for (let i = context.path.length - 1; i >= 0; i--) {
-			const ancestor = context.path[i];
-			if (
-				ancestor.type === 'Component' ||
-				ancestor.type === 'SvelteComponent' ||
-				ancestor.type === 'SvelteFragment' ||
-				ancestor.type === 'SnippetBlock'
-			) {
-				// Inside a slot or a snippet -> this resets the namespace, so assume the component namespace
-				node.metadata.svg = context.state.options.namespace === 'svg';
-				node.metadata.mathml = context.state.options.namespace === 'mathml';
-				return;
-			}
-			if (ancestor.type === 'SvelteElement' || ancestor.type === 'RegularElement') {
-				node.metadata.svg =
-					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
-						? false
-						: ancestor.metadata.svg;
-				node.metadata.mathml =
-					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
-						? false
-						: ancestor.metadata.mathml;
-				return;
-			}
-		}
-	},
-	Component(node, context) {
-		const binding = context.state.scope.get(
-			node.name.includes('.') ? node.name.slice(0, node.name.indexOf('.')) : node.name
-		);
-
-		node.metadata.dynamic =
-			context.state.analysis.runes && // Svelte 4 required you to use svelte:component to switch components
-			binding !== null &&
-			(binding.kind !== 'normal' || node.name.includes('.'));
-	},
-	RenderTag(node, context) {
-		context.next({ ...context.state, render_tag: node });
-	},
-	EachBlock(node) {
-		if (node.key) {
-			// treat `{#each items as item, i (i)}` as a normal indexed block, everything else as keyed
-			node.metadata.keyed =
-				node.key.type !== 'Identifier' || !node.index || node.key.name !== node.index;
-		}
-	}
-};
-
-/**
- * @param {RegularElement} node
- */
-function determine_element_spread(node) {
-	let has_spread = false;
-	for (const attribute of node.attributes) {
-		if (!has_spread && attribute.type === 'SpreadAttribute') {
-			has_spread = true;
-		}
-	}
-	node.metadata.has_spread = has_spread;
-
-	return node;
-}
-
-/**
- * @param {string} event_name
- */
-function get_attribute_event_name(event_name) {
-	if (is_capture_event(event_name, 'include-on')) {
-		event_name = event_name.slice(0, -7);
-	}
-	event_name = event_name.slice(2);
-	return event_name;
-}
-
 /**
- * @param {Map<LabeledStatement, ReactiveStatement>} unsorted_reactive_declarations
+ * @param {Map<import('estree').LabeledStatement, ReactiveStatement>} unsorted_reactive_declarations
  */
 function order_reactive_statements(unsorted_reactive_declarations) {
-	/** @typedef {[LabeledStatement, ReactiveStatement]} Tuple */
+	/** @typedef {[import('estree').LabeledStatement, ReactiveStatement]} Tuple */
 
 	/** @type {Map<string, Array<Tuple>>} */
 	const lookup = new Map();
@@ -1631,12 +659,12 @@ function order_reactive_statements(unsorted_reactive_declarations) {
 	}
 
 	// We use a map and take advantage of the fact that the spec says insertion order is preserved when iterating
-	/** @type {Map<LabeledStatement, ReactiveStatement>} */
+	/** @type {Map<import('estree').LabeledStatement, ReactiveStatement>} */
 	const reactive_declarations = new Map();
 
 	/**
 	 *
-	 * @param {LabeledStatement} node
+	 * @param {import('estree').LabeledStatement} node
 	 * @param {ReactiveStatement} declaration
 	 * @returns
 	 */
diff --git a/packages/svelte/src/compiler/phases/2-analyze/types.d.ts b/packages/svelte/src/compiler/phases/2-analyze/types.d.ts
index e03b9c9cc4..2cfe76b61a 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/types.d.ts
+++ b/packages/svelte/src/compiler/phases/2-analyze/types.d.ts
@@ -1,19 +1,11 @@
 import type { Scope } from '../scope.js';
 import type { ComponentAnalysis, ReactiveStatement } from '../types.js';
-import type {
-	ClassDirective,
-	ExpressionMetadata,
-	ExpressionTag,
-	OnDirective,
-	RenderTag,
-	SpreadAttribute,
-	SvelteNode,
-	ValidatedCompileOptions
-} from '#compiler';
+import type { ExpressionMetadata, RenderTag, SvelteNode, ValidatedCompileOptions } from '#compiler';
 import type { LabeledStatement } from 'estree';
 
 export interface AnalysisState {
 	scope: Scope;
+	scopes: Map<SvelteNode, Scope>;
 	analysis: ComponentAnalysis;
 	options: ValidatedCompileOptions;
 	ast_type: 'instance' | 'template' | 'module';
@@ -27,9 +19,8 @@ export interface AnalysisState {
 	render_tag: null | RenderTag;
 	private_derived_state: string[];
 	function_depth: number;
-}
 
-export interface LegacyAnalysisState extends AnalysisState {
+	// legacy stuff
 	instance_scope: Scope;
 	reactive_statement: null | ReactiveStatement;
 	reactive_statements: Map<LabeledStatement, ReactiveStatement>;
diff --git a/packages/svelte/src/compiler/phases/2-analyze/validation.js b/packages/svelte/src/compiler/phases/2-analyze/validation.js
deleted file mode 100644
index 67459fe5a1..0000000000
--- a/packages/svelte/src/compiler/phases/2-analyze/validation.js
+++ /dev/null
@@ -1,1443 +0,0 @@
-/** @import { AssignmentExpression, CallExpression, Expression, ImportDeclaration, Identifier, Node, Pattern, PrivateIdentifier, Super, UpdateExpression, VariableDeclarator } from 'estree' */
-/** @import { Attribute, Component, ElementLike, Fragment, RegularElement, SvelteComponent, SvelteElement, SvelteNode, SvelteSelf, TransitionDirective } from '#compiler' */
-/** @import { NodeLike } from '../../errors.js' */
-/** @import { AnalysisState, Context, Visitors } from './types.js' */
-import is_reference from 'is-reference';
-import * as e from '../../errors.js';
-import {
-	extract_identifiers,
-	get_attribute_expression,
-	get_parent,
-	is_expression_attribute,
-	is_text_attribute,
-	object,
-	unwrap_optional
-} from '../../utils/ast.js';
-import * as w from '../../warnings.js';
-import fuzzymatch from '../1-parse/utils/fuzzymatch.js';
-import { binding_properties } from '../bindings.js';
-import {
-	ContentEditableBindings,
-	EventModifiers,
-	Runes,
-	SVGElements,
-	VoidElements
-} from '../constants.js';
-import { is_custom_element_node } from '../nodes.js';
-import {
-	regex_illegal_attribute_character,
-	regex_not_whitespace,
-	regex_only_whitespaces
-} from '../patterns.js';
-import { Scope, get_rune } from '../scope.js';
-import { merge } from '../visitors.js';
-import { a11y_validators } from './a11y.js';
-import {
-	is_tag_valid_with_ancestor,
-	is_tag_valid_with_parent
-} from '../../../html-tree-validation.js';
-
-/**
- * @param {Attribute} attribute
- * @param {ElementLike} parent
- */
-function validate_attribute(attribute, parent) {
-	if (
-		Array.isArray(attribute.value) &&
-		attribute.value.length === 1 &&
-		attribute.value[0].type === 'ExpressionTag' &&
-		(parent.type === 'Component' ||
-			parent.type === 'SvelteComponent' ||
-			parent.type === 'SvelteSelf' ||
-			(parent.type === 'RegularElement' && is_custom_element_node(parent)))
-	) {
-		w.attribute_quoted(attribute);
-	}
-
-	if (attribute.value === true || !Array.isArray(attribute.value) || attribute.value.length === 1) {
-		return;
-	}
-
-	const is_quoted = attribute.value.at(-1)?.end !== attribute.end;
-
-	if (!is_quoted) {
-		e.attribute_unquoted_sequence(attribute);
-	}
-}
-
-/**
- * @param {Component | SvelteComponent | SvelteSelf} node
- * @param {Context} context
- */
-function validate_component(node, context) {
-	for (const attribute of node.attributes) {
-		if (
-			attribute.type !== 'Attribute' &&
-			attribute.type !== 'SpreadAttribute' &&
-			attribute.type !== 'LetDirective' &&
-			attribute.type !== 'OnDirective' &&
-			attribute.type !== 'BindDirective'
-		) {
-			e.component_invalid_directive(attribute);
-		}
-
-		if (
-			attribute.type === 'OnDirective' &&
-			(attribute.modifiers.length > 1 || attribute.modifiers.some((m) => m !== 'once'))
-		) {
-			e.event_handler_invalid_component_modifier(attribute);
-		}
-
-		if (attribute.type === 'Attribute') {
-			if (context.state.analysis.runes) {
-				validate_attribute(attribute, node);
-
-				if (is_expression_attribute(attribute)) {
-					const expression = get_attribute_expression(attribute);
-					if (expression.type === 'SequenceExpression') {
-						let i = /** @type {number} */ (expression.start);
-						while (--i > 0) {
-							const char = context.state.analysis.source[i];
-							if (char === '(') break; // parenthesized sequence expressions are ok
-							if (char === '{') e.attribute_invalid_sequence_expression(expression);
-						}
-					}
-				}
-			}
-
-			validate_attribute_name(attribute);
-
-			if (attribute.name === 'slot') {
-				validate_slot_attribute(context, attribute, true);
-			}
-		}
-	}
-
-	context.next({
-		...context.state,
-		parent_element: null,
-		component_slots: new Set()
-	});
-}
-
-const react_attributes = new Map([
-	['className', 'class'],
-	['htmlFor', 'for']
-]);
-
-/**
- * @param {RegularElement | SvelteElement} node
- * @param {Context} context
- */
-function validate_element(node, context) {
-	let has_animate_directive = false;
-
-	/** @type {TransitionDirective | null} */
-	let in_transition = null;
-
-	/** @type {TransitionDirective | null} */
-	let out_transition = null;
-
-	for (const attribute of node.attributes) {
-		if (attribute.type === 'Attribute') {
-			const is_expression = is_expression_attribute(attribute);
-
-			if (context.state.analysis.runes) {
-				validate_attribute(attribute, node);
-
-				if (is_expression) {
-					const expression = get_attribute_expression(attribute);
-					if (expression.type === 'SequenceExpression') {
-						let i = /** @type {number} */ (expression.start);
-						while (--i > 0) {
-							const char = context.state.analysis.source[i];
-							if (char === '(') break; // parenthesized sequence expressions are ok
-							if (char === '{') e.attribute_invalid_sequence_expression(expression);
-						}
-					}
-				}
-			}
-
-			if (regex_illegal_attribute_character.test(attribute.name)) {
-				e.attribute_invalid_name(attribute, attribute.name);
-			}
-
-			if (attribute.name.startsWith('on') && attribute.name.length > 2) {
-				if (!is_expression) {
-					e.attribute_invalid_event_handler(attribute);
-				}
-
-				const value = get_attribute_expression(attribute);
-				if (
-					value.type === 'Identifier' &&
-					value.name === attribute.name &&
-					!context.state.scope.get(value.name)
-				) {
-					w.attribute_global_event_reference(attribute, attribute.name);
-				}
-			}
-
-			if (attribute.name === 'slot') {
-				/** @type {RegularElement | SvelteElement | Component | SvelteComponent | SvelteSelf | undefined} */
-				validate_slot_attribute(context, attribute);
-			}
-
-			if (attribute.name === 'is' && context.state.options.namespace !== 'foreign') {
-				w.attribute_avoid_is(attribute);
-			}
-
-			const correct_name = react_attributes.get(attribute.name);
-			if (correct_name) {
-				w.attribute_invalid_property_name(attribute, attribute.name, correct_name);
-			}
-
-			validate_attribute_name(attribute);
-		} else if (attribute.type === 'AnimateDirective') {
-			const parent = context.path.at(-2);
-			if (parent?.type !== 'EachBlock') {
-				e.animation_invalid_placement(attribute);
-			} else if (!parent.key) {
-				e.animation_missing_key(attribute);
-			} else if (
-				parent.body.nodes.filter(
-					(n) =>
-						n.type !== 'Comment' &&
-						n.type !== 'ConstTag' &&
-						(n.type !== 'Text' || n.data.trim() !== '')
-				).length > 1
-			) {
-				e.animation_invalid_placement(attribute);
-			}
-
-			if (has_animate_directive) {
-				e.animation_duplicate(attribute);
-			} else {
-				has_animate_directive = true;
-			}
-		} else if (attribute.type === 'TransitionDirective') {
-			const existing = /** @type {TransitionDirective | null} */ (
-				(attribute.intro && in_transition) || (attribute.outro && out_transition)
-			);
-
-			if (existing) {
-				const a = existing.intro ? (existing.outro ? 'transition' : 'in') : 'out';
-				const b = attribute.intro ? (attribute.outro ? 'transition' : 'in') : 'out';
-
-				if (a === b) {
-					e.transition_duplicate(attribute, a);
-				} else {
-					e.transition_conflict(attribute, a, b);
-				}
-			}
-
-			if (attribute.intro) in_transition = attribute;
-			if (attribute.outro) out_transition = attribute;
-		} else if (attribute.type === 'OnDirective') {
-			let has_passive_modifier = false;
-			let conflicting_passive_modifier = '';
-			for (const modifier of attribute.modifiers) {
-				if (!EventModifiers.includes(modifier)) {
-					const list = `${EventModifiers.slice(0, -1).join(', ')} or ${EventModifiers.at(-1)}`;
-					e.event_handler_invalid_modifier(attribute, list);
-				}
-				if (modifier === 'passive') {
-					has_passive_modifier = true;
-				} else if (modifier === 'nonpassive' || modifier === 'preventDefault') {
-					conflicting_passive_modifier = modifier;
-				}
-				if (has_passive_modifier && conflicting_passive_modifier) {
-					e.event_handler_invalid_modifier_combination(
-						attribute,
-						'passive',
-						conflicting_passive_modifier
-					);
-				}
-			}
-		}
-	}
-}
-
-/**
- * @param {Attribute} attribute
- */
-function validate_attribute_name(attribute) {
-	if (
-		attribute.name.includes(':') &&
-		!attribute.name.startsWith('xmlns:') &&
-		!attribute.name.startsWith('xlink:') &&
-		!attribute.name.startsWith('xml:')
-	) {
-		w.attribute_illegal_colon(attribute);
-	}
-}
-
-/**
- * @param {Context} context
- * @param {Attribute} attribute
- * @param {boolean} is_component
- */
-function validate_slot_attribute(context, attribute, is_component = false) {
-	const parent = context.path.at(-2);
-	let owner = undefined;
-
-	if (parent?.type === 'SnippetBlock') {
-		if (!is_text_attribute(attribute)) {
-			e.slot_attribute_invalid(attribute);
-		}
-		return;
-	}
-
-	let i = context.path.length;
-	while (i--) {
-		const ancestor = context.path[i];
-		if (
-			!owner &&
-			(ancestor.type === 'Component' ||
-				ancestor.type === 'SvelteComponent' ||
-				ancestor.type === 'SvelteSelf' ||
-				ancestor.type === 'SvelteElement' ||
-				(ancestor.type === 'RegularElement' && is_custom_element_node(ancestor)))
-		) {
-			owner = ancestor;
-		}
-	}
-
-	if (owner) {
-		if (!is_text_attribute(attribute)) {
-			e.slot_attribute_invalid(attribute);
-		}
-
-		if (
-			owner.type === 'Component' ||
-			owner.type === 'SvelteComponent' ||
-			owner.type === 'SvelteSelf'
-		) {
-			if (owner !== parent) {
-				e.slot_attribute_invalid_placement(attribute);
-			}
-
-			const name = attribute.value[0].data;
-
-			if (context.state.component_slots.has(name)) {
-				e.slot_attribute_duplicate(attribute, name, owner.name);
-			}
-
-			context.state.component_slots.add(name);
-
-			if (name === 'default') {
-				for (const node of owner.fragment.nodes) {
-					if (node.type === 'Text' && regex_only_whitespaces.test(node.data)) {
-						continue;
-					}
-
-					if (node.type === 'RegularElement' || node.type === 'SvelteFragment') {
-						if (node.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')) {
-							continue;
-						}
-					}
-
-					e.slot_default_duplicate(node);
-				}
-			}
-		}
-	} else if (!is_component) {
-		e.slot_attribute_invalid_placement(attribute);
-	}
-}
-
-/**
- * @param {Fragment | null | undefined} node
- * @param {Context} context
- */
-function validate_block_not_empty(node, context) {
-	if (!node) return;
-	// Assumption: If the block has zero elements, someone's in the middle of typing it out,
-	// so don't warn in that case because it would be distracting.
-	if (node.nodes.length === 1 && node.nodes[0].type === 'Text' && !node.nodes[0].raw.trim()) {
-		w.block_empty(node.nodes[0]);
-	}
-}
-
-/**
- * @type {Visitors}
- */
-const validation = {
-	ExpressionStatement(node, { state }) {
-		if (
-			node.expression.type === 'NewExpression' &&
-			node.expression.callee.type === 'Identifier' &&
-			node.expression.arguments.length === 1 &&
-			node.expression.arguments[0].type === 'ObjectExpression' &&
-			node.expression.arguments[0].properties.some(
-				(p) => p.type === 'Property' && p.key.type === 'Identifier' && p.key.name === 'target'
-			)
-		) {
-			const binding = state.scope.get(node.expression.callee.name);
-			if (binding?.kind === 'normal' && binding.declaration_kind === 'import') {
-				const declaration = /** @type {ImportDeclaration} */ (binding.initial);
-
-				// Theoretically someone could import a class from a `.svelte.js` module, but that's too rare to worry about
-				if (
-					/** @type {string} */ (declaration.source.value)?.endsWith('.svelte') &&
-					declaration.specifiers.find(
-						(s) => s.local.name === binding.node.name && s.type === 'ImportDefaultSpecifier'
-					)
-				) {
-					w.legacy_component_creation(node.expression);
-				}
-			}
-		}
-	},
-	MemberExpression(node, context) {
-		if (node.object.type === 'Identifier' && node.property.type === 'Identifier') {
-			const binding = context.state.scope.get(node.object.name);
-			if (binding?.kind === 'rest_prop' && node.property.name.startsWith('$$')) {
-				e.props_illegal_name(node.property);
-			}
-		}
-	},
-	AssignmentExpression(node, context) {
-		validate_assignment(node, node.left, context.state);
-	},
-	BindDirective(node, context) {
-		validate_no_const_assignment(node, node.expression, context.state.scope, true);
-
-		const assignee = node.expression;
-		const left = object(assignee);
-
-		if (left === null) {
-			e.bind_invalid_expression(node);
-		}
-
-		const binding = context.state.scope.get(left.name);
-
-		if (assignee.type === 'Identifier') {
-			// reassignment
-			if (
-				node.name !== 'this' && // bind:this also works for regular variables
-				(!binding ||
-					(binding.kind !== 'state' &&
-						binding.kind !== 'frozen_state' &&
-						binding.kind !== 'prop' &&
-						binding.kind !== 'bindable_prop' &&
-						binding.kind !== 'each' &&
-						binding.kind !== 'store_sub' &&
-						!binding.mutated))
-			) {
-				e.bind_invalid_value(node.expression);
-			}
-
-			if (binding?.kind === 'derived') {
-				e.constant_binding(node.expression, 'derived state');
-			}
-
-			if (context.state.analysis.runes && binding?.kind === 'each') {
-				e.each_item_invalid_assignment(node);
-			}
-
-			if (binding?.kind === 'snippet') {
-				e.snippet_parameter_assignment(node);
-			}
-		}
-
-		if (node.name === 'group') {
-			if (!binding) {
-				throw new Error('Cannot find declaration for bind:group');
-			}
-		}
-
-		if (binding?.kind === 'each' && binding.metadata?.inside_rest) {
-			w.bind_invalid_each_rest(binding.node, binding.node.name);
-		}
-
-		const parent = context.path.at(-1);
-
-		if (
-			parent?.type === 'RegularElement' ||
-			parent?.type === 'SvelteElement' ||
-			parent?.type === 'SvelteWindow' ||
-			parent?.type === 'SvelteDocument' ||
-			parent?.type === 'SvelteBody'
-		) {
-			if (context.state.options.namespace === 'foreign' && node.name !== 'this') {
-				e.bind_invalid_name(node, node.name, 'Foreign elements only support `bind:this`');
-			}
-
-			if (node.name in binding_properties) {
-				const property = binding_properties[node.name];
-				if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
-					e.bind_invalid_target(
-						node,
-						node.name,
-						property.valid_elements.map((valid_element) => `<${valid_element}>`).join(', ')
-					);
-				}
-
-				if (property.invalid_elements && property.invalid_elements.includes(parent.name)) {
-					const valid_bindings = Object.entries(binding_properties)
-						.filter(([_, binding_property]) => {
-							return (
-								binding_property.valid_elements?.includes(parent.name) ||
-								(!binding_property.valid_elements &&
-									!binding_property.invalid_elements?.includes(parent.name))
-							);
-						})
-						.map(([property_name]) => property_name)
-						.sort();
-					e.bind_invalid_name(
-						node,
-						node.name,
-						`Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
-					);
-				}
-
-				if (parent.name === 'input' && node.name !== 'this') {
-					const type = /** @type {Attribute | undefined} */ (
-						parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'type')
-					);
-					if (type && !is_text_attribute(type)) {
-						if (node.name !== 'value' || type.value === true) {
-							e.attribute_invalid_type(type);
-						}
-						return; // bind:value can handle dynamic `type` attributes
-					}
-
-					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
-						e.bind_invalid_target(node, node.name, '<input type="checkbox">');
-					}
-
-					if (node.name === 'files' && type?.value[0].data !== 'file') {
-						e.bind_invalid_target(node, node.name, '<input type="file">');
-					}
-				}
-
-				if (parent.name === 'select' && node.name !== 'this') {
-					const multiple = parent.attributes.find(
-						(a) =>
-							a.type === 'Attribute' &&
-							a.name === 'multiple' &&
-							!is_text_attribute(a) &&
-							a.value !== true
-					);
-					if (multiple) {
-						e.attribute_invalid_multiple(multiple);
-					}
-				}
-
-				if (node.name === 'offsetWidth' && SVGElements.includes(parent.name)) {
-					e.bind_invalid_target(
-						node,
-						node.name,
-						`non-<svg> elements. Use 'clientWidth' for <svg> instead`
-					);
-				}
-
-				if (ContentEditableBindings.includes(node.name)) {
-					const contenteditable = /** @type {Attribute} */ (
-						parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'contenteditable')
-					);
-					if (!contenteditable) {
-						e.attribute_contenteditable_missing(node);
-					} else if (!is_text_attribute(contenteditable) && contenteditable.value !== true) {
-						e.attribute_contenteditable_dynamic(contenteditable);
-					}
-				}
-			} else {
-				const match = fuzzymatch(node.name, Object.keys(binding_properties));
-				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, node.name);
-			}
-		}
-	},
-	ExportDefaultDeclaration(node) {
-		e.module_illegal_default_export(node);
-	},
-	ConstTag(node, context) {
-		const parent = context.path.at(-1);
-		const grand_parent = context.path.at(-2);
-		if (
-			parent?.type !== 'Fragment' ||
-			(grand_parent?.type !== 'IfBlock' &&
-				grand_parent?.type !== 'SvelteFragment' &&
-				grand_parent?.type !== 'Component' &&
-				grand_parent?.type !== 'SvelteComponent' &&
-				grand_parent?.type !== 'EachBlock' &&
-				grand_parent?.type !== 'AwaitBlock' &&
-				grand_parent?.type !== 'SnippetBlock' &&
-				((grand_parent?.type !== 'RegularElement' && grand_parent?.type !== 'SvelteElement') ||
-					!grand_parent.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')))
-		) {
-			e.const_tag_invalid_placement(node);
-		}
-	},
-	ImportDeclaration(node, context) {
-		if (node.source.value === 'svelte' && context.state.analysis.runes) {
-			for (const specifier of node.specifiers) {
-				if (specifier.type === 'ImportSpecifier') {
-					if (
-						specifier.imported.name === 'beforeUpdate' ||
-						specifier.imported.name === 'afterUpdate'
-					) {
-						e.runes_mode_invalid_import(specifier, specifier.imported.name);
-					}
-				}
-			}
-		}
-	},
-	LetDirective(node, context) {
-		const parent = context.path.at(-1);
-		if (
-			parent === undefined ||
-			(parent.type !== 'Component' &&
-				parent.type !== 'RegularElement' &&
-				parent.type !== 'SlotElement' &&
-				parent.type !== 'SvelteElement' &&
-				parent.type !== 'SvelteComponent' &&
-				parent.type !== 'SvelteSelf' &&
-				parent.type !== 'SvelteFragment')
-		) {
-			e.let_directive_invalid_placement(node);
-		}
-	},
-	RegularElement(node, context) {
-		if (node.name === 'textarea' && node.fragment.nodes.length > 0) {
-			for (const attribute of node.attributes) {
-				if (attribute.type === 'Attribute' && attribute.name === 'value') {
-					e.textarea_invalid_content(node);
-				}
-			}
-		}
-
-		const binding = context.state.scope.get(node.name);
-		if (
-			binding !== null &&
-			binding.declaration_kind === 'import' &&
-			binding.references.length === 0
-		) {
-			w.component_name_lowercase(node, node.name);
-		}
-
-		validate_element(node, context);
-
-		if (context.state.parent_element) {
-			let past_parent = false;
-			let only_warn = false;
-
-			for (let i = context.path.length - 1; i >= 0; i--) {
-				const ancestor = context.path[i];
-
-				if (
-					ancestor.type === 'IfBlock' ||
-					ancestor.type === 'EachBlock' ||
-					ancestor.type === 'AwaitBlock' ||
-					ancestor.type === 'KeyBlock'
-				) {
-					// We're creating a separate template string inside blocks, which means client-side this would work
-					only_warn = true;
-				}
-
-				if (!past_parent) {
-					if (
-						ancestor.type === 'RegularElement' &&
-						ancestor.name === context.state.parent_element
-					) {
-						if (!is_tag_valid_with_parent(node.name, context.state.parent_element)) {
-							if (only_warn) {
-								w.node_invalid_placement_ssr(
-									node,
-									`\`<${node.name}>\``,
-									context.state.parent_element
-								);
-							} else {
-								e.node_invalid_placement(node, `\`<${node.name}>\``, context.state.parent_element);
-							}
-						}
-
-						past_parent = true;
-					}
-				} else if (ancestor.type === 'RegularElement') {
-					if (!is_tag_valid_with_ancestor(node.name, ancestor.name)) {
-						if (only_warn) {
-							w.node_invalid_placement_ssr(node, `\`<${node.name}>\``, ancestor.name);
-						} else {
-							e.node_invalid_placement(node, `\`<${node.name}>\``, ancestor.name);
-						}
-					}
-				} else if (
-					ancestor.type === 'Component' ||
-					ancestor.type === 'SvelteComponent' ||
-					ancestor.type === 'SvelteElement' ||
-					ancestor.type === 'SvelteSelf' ||
-					ancestor.type === 'SnippetBlock'
-				) {
-					break;
-				}
-			}
-		}
-
-		// Strip off any namespace from the beginning of the node name.
-		const node_name = node.name.replace(/[a-zA-Z-]*:/g, '');
-
-		if (
-			context.state.analysis.source[node.end - 2] === '/' &&
-			context.state.options.namespace !== 'foreign' &&
-			!VoidElements.includes(node_name) &&
-			!SVGElements.includes(node_name)
-		) {
-			w.element_invalid_self_closing_tag(node, node.name);
-		}
-
-		context.next({
-			...context.state,
-			parent_element: node.name
-		});
-	},
-	RenderTag(node, context) {
-		const callee = unwrap_optional(node.expression).callee;
-
-		node.metadata.dynamic =
-			callee.type !== 'Identifier' || context.state.scope.get(callee.name)?.kind !== 'normal';
-
-		context.state.analysis.uses_render_tags = true;
-
-		const raw_args = unwrap_optional(node.expression).arguments;
-		for (const arg of raw_args) {
-			if (arg.type === 'SpreadElement') {
-				e.render_tag_invalid_spread_argument(arg);
-			}
-		}
-
-		if (
-			callee.type === 'MemberExpression' &&
-			callee.property.type === 'Identifier' &&
-			['bind', 'apply', 'call'].includes(callee.property.name)
-		) {
-			e.render_tag_invalid_call_expression(node);
-		}
-	},
-	IfBlock(node, context) {
-		validate_block_not_empty(node.consequent, context);
-		validate_block_not_empty(node.alternate, context);
-	},
-	EachBlock(node, context) {
-		validate_block_not_empty(node.body, context);
-		validate_block_not_empty(node.fallback, context);
-	},
-	AwaitBlock(node, context) {
-		validate_block_not_empty(node.pending, context);
-		validate_block_not_empty(node.then, context);
-		validate_block_not_empty(node.catch, context);
-	},
-	KeyBlock(node, context) {
-		validate_block_not_empty(node.fragment, context);
-	},
-	SnippetBlock(node, context) {
-		validate_block_not_empty(node.body, context);
-
-		for (const arg of node.parameters) {
-			if (arg.type === 'RestElement') {
-				e.snippet_invalid_rest_parameter(arg);
-			}
-		}
-
-		context.next({ ...context.state, parent_element: null });
-
-		const { path } = context;
-		const parent = path.at(-2);
-		if (!parent) return;
-
-		if (
-			parent.type === 'Component' &&
-			parent.attributes.some(
-				(attribute) =>
-					(attribute.type === 'Attribute' || attribute.type === 'BindDirective') &&
-					attribute.name === node.expression.name
-			)
-		) {
-			e.snippet_shadowing_prop(node, node.expression.name);
-		}
-
-		if (node.expression.name !== 'children') return;
-
-		if (
-			parent.type === 'Component' ||
-			parent.type === 'SvelteComponent' ||
-			parent.type === 'SvelteSelf'
-		) {
-			if (
-				parent.fragment.nodes.some(
-					(node) => node.type !== 'SnippetBlock' && (node.type !== 'Text' || node.data.trim())
-				)
-			) {
-				e.snippet_conflict(node);
-			}
-		}
-	},
-	StyleDirective(node) {
-		if (node.modifiers.length > 1 || (node.modifiers.length && node.modifiers[0] !== 'important')) {
-			e.style_directive_invalid_modifier(node);
-		}
-	},
-	SvelteHead(node) {
-		const attribute = node.attributes[0];
-		if (attribute) {
-			e.svelte_head_illegal_attribute(attribute);
-		}
-	},
-	SvelteElement(node, context) {
-		validate_element(node, context);
-		context.next({
-			...context.state,
-			parent_element: null
-		});
-	},
-	SvelteFragment(node, context) {
-		const parent = context.path.at(-2);
-		if (parent?.type !== 'Component' && parent?.type !== 'SvelteComponent') {
-			e.svelte_fragment_invalid_placement(node);
-		}
-
-		for (const attribute of node.attributes) {
-			if (attribute.type === 'Attribute') {
-				if (attribute.name === 'slot') {
-					validate_slot_attribute(context, attribute);
-				}
-			} else if (attribute.type !== 'LetDirective') {
-				e.svelte_fragment_invalid_attribute(attribute);
-			}
-		}
-	},
-	SlotElement(node) {
-		for (const attribute of node.attributes) {
-			if (attribute.type === 'Attribute') {
-				if (attribute.name === 'name') {
-					if (!is_text_attribute(attribute)) {
-						e.slot_element_invalid_name(attribute);
-					}
-					const slot_name = attribute.value[0].data;
-					if (slot_name === 'default') {
-						e.slot_element_invalid_name_default(attribute);
-					}
-				}
-			} else if (attribute.type !== 'SpreadAttribute' && attribute.type !== 'LetDirective') {
-				e.slot_element_invalid_attribute(attribute);
-			}
-		}
-	},
-	Component: validate_component,
-	SvelteComponent: validate_component,
-	SvelteSelf: validate_component,
-	Text(node, context) {
-		if (!node.parent) return;
-		if (context.state.parent_element && regex_not_whitespace.test(node.data)) {
-			if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
-				e.node_invalid_placement(node, 'Text node', context.state.parent_element);
-			}
-		}
-	},
-	TitleElement(node) {
-		const attribute = node.attributes[0];
-		if (attribute) {
-			e.title_illegal_attribute(attribute);
-		}
-
-		const child = node.fragment.nodes.find((n) => n.type !== 'Text' && n.type !== 'ExpressionTag');
-		if (child) {
-			e.title_invalid_content(child);
-		}
-	},
-	UpdateExpression(node, context) {
-		validate_assignment(node, node.argument, context.state);
-	},
-	ExpressionTag(node, context) {
-		if (!node.parent) return;
-		if (context.state.parent_element) {
-			if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
-				e.node_invalid_placement(node, '`{expression}`', context.state.parent_element);
-			}
-		}
-	}
-};
-
-export const validation_legacy = merge(validation, a11y_validators, {
-	VariableDeclarator(node, { state }) {
-		ensure_no_module_import_conflict(node, state);
-
-		if (node.init?.type !== 'CallExpression') return;
-
-		const callee = node.init.callee;
-		if (
-			callee.type !== 'Identifier' ||
-			(callee.name !== '$state' && callee.name !== '$derived' && callee.name !== '$props')
-		) {
-			return;
-		}
-
-		if (state.scope.get(callee.name)?.kind !== 'store_sub') {
-			e.rune_invalid_usage(node.init, callee.name);
-		}
-	},
-	AssignmentExpression(node, { state, path }) {
-		const parent = path.at(-1);
-		if (parent && parent.type === 'ConstTag') return;
-		validate_assignment(node, node.left, state);
-	},
-	LabeledStatement(node, { path, state }) {
-		if (
-			node.label.name === '$' &&
-			(state.ast_type !== 'instance' || /** @type {SvelteNode} */ (path.at(-1)).type !== 'Program')
-		) {
-			w.reactive_declaration_invalid_placement(node);
-		}
-	},
-	UpdateExpression(node, { state }) {
-		validate_assignment(node, node.argument, state);
-	}
-});
-
-/**
- *
- * @param {Node} node
- * @param {Scope} scope
- * @param {string} name
- */
-function validate_export(node, scope, name) {
-	const binding = scope.get(name);
-	if (!binding) return;
-
-	if (binding.kind === 'derived') {
-		e.derived_invalid_export(node);
-	}
-
-	if ((binding.kind === 'state' || binding.kind === 'frozen_state') && binding.reassigned) {
-		e.state_invalid_export(node);
-	}
-}
-
-/**
- * @param {CallExpression} node
- * @param {Scope} scope
- * @param {SvelteNode[]} path
- * @returns
- */
-function validate_call_expression(node, scope, path) {
-	const rune = get_rune(node, scope);
-	if (rune === null) return;
-
-	const parent = /** @type {SvelteNode} */ (get_parent(path, -1));
-
-	if (rune === '$props') {
-		if (parent.type === 'VariableDeclarator') return;
-		e.props_invalid_placement(node);
-	}
-
-	if (rune === '$bindable') {
-		if (parent.type === 'AssignmentPattern' && path.at(-3)?.type === 'ObjectPattern') {
-			const declarator = path.at(-4);
-			if (
-				declarator?.type === 'VariableDeclarator' &&
-				get_rune(declarator.init, scope) === '$props'
-			) {
-				return;
-			}
-		}
-		e.bindable_invalid_location(node);
-	}
-
-	if (
-		rune === '$state' ||
-		rune === '$state.frozen' ||
-		rune === '$derived' ||
-		rune === '$derived.by'
-	) {
-		if (parent.type === 'VariableDeclarator') return;
-		if (parent.type === 'PropertyDefinition' && !parent.static && !parent.computed) return;
-		e.state_invalid_placement(node, rune);
-	}
-
-	if (rune === '$effect' || rune === '$effect.pre') {
-		if (parent.type !== 'ExpressionStatement') {
-			e.effect_invalid_placement(node);
-		}
-
-		if (node.arguments.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		}
-	}
-
-	if (rune === '$effect.tracking') {
-		if (node.arguments.length !== 0) {
-			e.rune_invalid_arguments(node, rune);
-		}
-	}
-
-	if (rune === '$effect.root') {
-		if (node.arguments.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		}
-	}
-
-	if (rune === '$inspect') {
-		if (node.arguments.length < 1) {
-			e.rune_invalid_arguments_length(node, rune, 'one or more arguments');
-		}
-	}
-
-	if (rune === '$inspect().with') {
-		if (node.arguments.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		}
-	}
-
-	if (rune === '$state.snapshot') {
-		if (node.arguments.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		}
-	}
-
-	if (rune === '$state.is') {
-		if (node.arguments.length !== 2) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly two arguments');
-		}
-	}
-}
-
-/**
- * @param {VariableDeclarator} node
- * @param {AnalysisState} state
- */
-function ensure_no_module_import_conflict(node, state) {
-	const ids = extract_identifiers(node.id);
-	for (const id of ids) {
-		if (
-			state.scope === state.analysis.instance.scope &&
-			state.analysis.module.scope.get(id.name)?.declaration_kind === 'import'
-		) {
-			e.declaration_duplicate_module_import(node.id);
-		}
-	}
-}
-
-/**
- * @type {Visitors}
- */
-export const validation_runes_js = {
-	ImportDeclaration(node) {
-		if (typeof node.source.value === 'string' && node.source.value.startsWith('svelte/internal')) {
-			e.import_svelte_internal_forbidden(node);
-		}
-	},
-	ExportSpecifier(node, { state }) {
-		validate_export(node, state.scope, node.local.name);
-	},
-	ExportNamedDeclaration(node, { state, next }) {
-		if (node.declaration?.type !== 'VariableDeclaration') return;
-
-		// visit children, so bindings are correctly initialised
-		next();
-
-		for (const declarator of node.declaration.declarations) {
-			for (const id of extract_identifiers(declarator.id)) {
-				validate_export(node, state.scope, id.name);
-			}
-		}
-	},
-	CallExpression(node, { state, path }) {
-		if (get_rune(node, state.scope) === '$host') {
-			e.host_invalid_placement(node);
-		}
-		validate_call_expression(node, state.scope, path);
-	},
-	VariableDeclarator(node, { state }) {
-		const init = node.init;
-		const rune = get_rune(init, state.scope);
-
-		if (rune === null) return;
-
-		const args = /** @type {CallExpression} */ (init).arguments;
-
-		if ((rune === '$derived' || rune === '$derived.by') && args.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		} else if (rune === '$state' && args.length > 1) {
-			e.rune_invalid_arguments_length(node, rune, 'zero or one arguments');
-		} else if (rune === '$props') {
-			e.props_invalid_placement(node);
-		} else if (rune === '$bindable') {
-			e.bindable_invalid_location(node);
-		}
-	},
-	AssignmentExpression(node, { state }) {
-		validate_assignment(node, node.left, state);
-	},
-	UpdateExpression(node, { state }) {
-		validate_assignment(node, node.argument, state);
-	},
-	ClassBody(node, context) {
-		/** @type {string[]} */
-		const private_derived_state = [];
-
-		for (const definition of node.body) {
-			if (
-				definition.type === 'PropertyDefinition' &&
-				definition.key.type === 'PrivateIdentifier' &&
-				definition.value?.type === 'CallExpression'
-			) {
-				const rune = get_rune(definition.value, context.state.scope);
-				if (rune === '$derived' || rune === '$derived.by') {
-					private_derived_state.push(definition.key.name);
-				}
-			}
-		}
-
-		context.next({
-			...context.state,
-			private_derived_state
-		});
-	},
-	ClassDeclaration(node, context) {
-		// In modules, we allow top-level module scope only, in components, we allow the component scope,
-		// which is function_depth of 1. With the exception of `new class` which is also not allowed at
-		// component scope level either.
-		const allowed_depth = context.state.ast_type === 'module' ? 0 : 1;
-
-		if (context.state.scope.function_depth > allowed_depth) {
-			w.perf_avoid_nested_class(node);
-		}
-	},
-	NewExpression(node, context) {
-		if (node.callee.type === 'ClassExpression' && context.state.scope.function_depth > 0) {
-			w.perf_avoid_inline_class(node);
-		}
-	},
-	Identifier(node, { path, state }) {
-		let i = path.length;
-		let parent = /** @type {Expression} */ (path[--i]);
-
-		if (
-			Runes.includes(/** @type {Runes[number]} */ (node.name)) &&
-			is_reference(node, parent) &&
-			state.scope.get(node.name) === null &&
-			state.scope.get(node.name.slice(1)) === null
-		) {
-			/** @type {Expression} */
-			let current = node;
-			let name = node.name;
-
-			while (parent.type === 'MemberExpression') {
-				if (parent.computed) e.rune_invalid_computed_property(parent);
-				name += `.${/** @type {Identifier} */ (parent.property).name}`;
-
-				current = parent;
-				parent = /** @type {Expression} */ (path[--i]);
-
-				if (!Runes.includes(/** @type {Runes[number]} */ (name))) {
-					if (name === '$effect.active') {
-						e.rune_renamed(parent, '$effect.active', '$effect.tracking');
-					}
-
-					e.rune_invalid_name(parent, name);
-				}
-			}
-
-			if (parent.type !== 'CallExpression') {
-				e.rune_missing_parentheses(current);
-			}
-		}
-	}
-};
-
-/**
- * @param {NodeLike} node
- * @param {Pattern | Expression} argument
- * @param {Scope} scope
- * @param {boolean} is_binding
- */
-function validate_no_const_assignment(node, argument, scope, is_binding) {
-	if (argument.type === 'ArrayPattern') {
-		for (const element of argument.elements) {
-			if (element) {
-				validate_no_const_assignment(node, element, scope, is_binding);
-			}
-		}
-	} else if (argument.type === 'ObjectPattern') {
-		for (const element of argument.properties) {
-			if (element.type === 'Property') {
-				validate_no_const_assignment(node, element.value, scope, is_binding);
-			}
-		}
-	} else if (argument.type === 'Identifier') {
-		const binding = scope.get(argument.name);
-		if (binding?.declaration_kind === 'const' && binding.kind !== 'each') {
-			// e.invalid_const_assignment(
-			// 	node,
-			// 	is_binding,
-			// 	// This takes advantage of the fact that we don't assign initial for let directives and then/catch variables.
-			// 	// If we start doing that, we need another property on the binding to differentiate, or give up on the more precise error message.
-			// 	binding.kind !== 'state' &&
-			// 		binding.kind !== 'frozen_state' &&
-			// 		(binding.kind !== 'normal' || !binding.initial)
-			// );
-
-			// TODO have a more specific error message for assignments to things like `{:then foo}`
-			const thing = 'constant';
-
-			if (is_binding) {
-				e.constant_binding(node, thing);
-			} else {
-				e.constant_assignment(node, thing);
-			}
-		}
-	}
-}
-
-/**
- * Validates that the opening of a control flow block is `{` immediately followed by the expected character.
- * In legacy mode whitespace is allowed inbetween. TODO remove once legacy mode is gone and move this into parser instead.
- * @param {{start: number; end: number}} node
- * @param {AnalysisState} state
- * @param {string} expected
- */
-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);
-	}
-}
-
-/**
- * @param {AssignmentExpression | UpdateExpression} node
- * @param {Pattern | Expression} argument
- * @param {AnalysisState} state
- */
-function validate_assignment(node, argument, state) {
-	validate_no_const_assignment(node, argument, state.scope, false);
-
-	if (argument.type === 'Identifier') {
-		const binding = state.scope.get(argument.name);
-
-		if (state.analysis.runes) {
-			if (binding?.kind === 'derived') {
-				e.constant_assignment(node, 'derived state');
-			}
-
-			if (binding?.kind === 'each') {
-				e.each_item_invalid_assignment(node);
-			}
-		}
-
-		if (binding?.kind === 'snippet') {
-			e.snippet_parameter_assignment(node);
-		}
-	}
-
-	let object = /** @type {Expression | Super} */ (argument);
-
-	/** @type {Expression | PrivateIdentifier | null} */
-	let property = null;
-
-	while (object.type === 'MemberExpression') {
-		property = object.property;
-		object = object.object;
-	}
-
-	if (object.type === 'ThisExpression' && property?.type === 'PrivateIdentifier') {
-		if (state.private_derived_state.includes(property.name)) {
-			e.constant_assignment(node, 'derived state');
-		}
-	}
-}
-
-export const validation_runes = merge(validation, a11y_validators, {
-	ImportDeclaration(node) {
-		if (typeof node.source.value === 'string' && node.source.value.startsWith('svelte/internal')) {
-			e.import_svelte_internal_forbidden(node);
-		}
-	},
-	LabeledStatement(node, { path }) {
-		if (node.label.name !== '$' || path.at(-1)?.type !== 'Program') return;
-		e.legacy_reactive_statement_invalid(node);
-	},
-	ExportNamedDeclaration(node, { state, next }) {
-		if (state.ast_type === 'module') {
-			if (node.declaration?.type !== 'VariableDeclaration') return;
-
-			// visit children, so bindings are correctly initialised
-			next();
-
-			for (const declarator of node.declaration.declarations) {
-				for (const id of extract_identifiers(declarator.id)) {
-					validate_export(node, state.scope, id.name);
-				}
-			}
-		} else {
-			if (node.declaration?.type !== 'VariableDeclaration') return;
-			if (node.declaration.kind !== 'let') return;
-			if (state.analysis.instance.scope !== state.scope) return;
-			e.legacy_export_invalid(node);
-		}
-	},
-	ExportSpecifier(node, { state }) {
-		if (state.ast_type === 'module') {
-			validate_export(node, state.scope, node.local.name);
-		}
-	},
-	CallExpression(node, { state, path }) {
-		const rune = get_rune(node, state.scope);
-		if (rune === '$bindable' && node.arguments.length > 1) {
-			e.rune_invalid_arguments_length(node, '$bindable', 'zero or one arguments');
-		} else if (rune === '$host') {
-			if (node.arguments.length > 0) {
-				e.rune_invalid_arguments(node, '$host');
-			} else if (state.ast_type === 'module' || !state.analysis.custom_element) {
-				e.host_invalid_placement(node);
-			}
-		}
-
-		validate_call_expression(node, state.scope, path);
-	},
-	EachBlock(node, { next, state }) {
-		validate_opening_tag(node, state, '#');
-
-		const context = node.context;
-		if (
-			context.type === 'Identifier' &&
-			(context.name === '$state' || context.name === '$derived')
-		) {
-			e.state_invalid_placement(node, context.name);
-		}
-		next({ ...state });
-	},
-	IfBlock(node, { state, path }) {
-		const parent = path.at(-1);
-		const expected =
-			path.at(-2)?.type === 'IfBlock' && parent?.type === 'Fragment' && parent.nodes.length === 1
-				? ':'
-				: '#';
-		validate_opening_tag(node, state, expected);
-	},
-	AwaitBlock(node, { state }) {
-		validate_opening_tag(node, state, '#');
-
-		if (node.value) {
-			const start = /** @type {number} */ (node.value.start);
-			const match = state.analysis.source.substring(start - 10, start).match(/{(\s*):then\s+$/);
-			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
-			}
-		}
-
-		if (node.error) {
-			const start = /** @type {number} */ (node.error.start);
-			const match = state.analysis.source.substring(start - 10, start).match(/{(\s*):catch\s+$/);
-			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
-			}
-		}
-	},
-	KeyBlock(node, { state }) {
-		validate_opening_tag(node, state, '#');
-	},
-	SnippetBlock(node, { state }) {
-		validate_opening_tag(node, state, '#');
-	},
-	ConstTag(node, { state }) {
-		validate_opening_tag(node, state, '@');
-	},
-	HtmlTag(node, { state }) {
-		validate_opening_tag(node, state, '@');
-	},
-	DebugTag(node, { state }) {
-		validate_opening_tag(node, state, '@');
-	},
-	RenderTag(node, { state }) {
-		validate_opening_tag(node, state, '@');
-	},
-	VariableDeclarator(node, { state }) {
-		ensure_no_module_import_conflict(node, state);
-
-		const init = node.init;
-		const rune = get_rune(init, state.scope);
-
-		if (rune === null) return;
-
-		const args = /** @type {CallExpression} */ (init).arguments;
-
-		// TODO some of this is duplicated with above, seems off
-		if ((rune === '$derived' || rune === '$derived.by') && args.length !== 1) {
-			e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
-		} else if (rune === '$state' && args.length > 1) {
-			e.rune_invalid_arguments_length(node, rune, 'zero or one arguments');
-		} else if (rune === '$props') {
-			if (state.has_props_rune) {
-				e.props_duplicate(node);
-			}
-
-			state.has_props_rune = true;
-
-			if (args.length > 0) {
-				e.rune_invalid_arguments(node, rune);
-			}
-
-			if (node.id.type !== 'ObjectPattern' && node.id.type !== 'Identifier') {
-				e.props_invalid_identifier(node);
-			}
-
-			if (state.scope !== state.analysis.instance.scope) {
-				e.props_invalid_placement(node);
-			}
-
-			if (node.id.type === 'ObjectPattern') {
-				for (const property of node.id.properties) {
-					if (property.type === 'Property') {
-						if (property.computed) {
-							e.props_invalid_pattern(property);
-						}
-
-						if (property.key.type === 'Identifier' && property.key.name.startsWith('$$')) {
-							e.props_illegal_name(property);
-						}
-
-						const value =
-							property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
-
-						if (value.type !== 'Identifier') {
-							e.props_invalid_pattern(property);
-						}
-					}
-				}
-			}
-		}
-
-		if (rune === '$derived') {
-			const arg = args[0];
-			if (
-				arg.type === 'CallExpression' &&
-				(arg.callee.type === 'ArrowFunctionExpression' || arg.callee.type === 'FunctionExpression')
-			) {
-				w.derived_iife(node);
-			}
-		}
-	},
-	SlotElement(node, { state }) {
-		if (!state.analysis.custom_element) {
-			w.slot_element_deprecated(node);
-		}
-	},
-	OnDirective(node, { path }) {
-		const parent_type = path.at(-1)?.type;
-		// 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);
-		}
-	},
-	// TODO this is a code smell. need to refactor this stuff
-	ClassBody: validation_runes_js.ClassBody,
-	ClassDeclaration: validation_runes_js.ClassDeclaration,
-	Identifier: validation_runes_js.Identifier,
-	NewExpression: validation_runes_js.NewExpression
-});
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ArrowFunctionExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ArrowFunctionExpression.js
new file mode 100644
index 0000000000..adafebaee8
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ArrowFunctionExpression.js
@@ -0,0 +1,11 @@
+/** @import { ArrowFunctionExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { visit_function } from './shared/function.js';
+
+/**
+ * @param {ArrowFunctionExpression} node
+ * @param {Context} context
+ */
+export function ArrowFunctionExpression(node, context) {
+	visit_function(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
new file mode 100644
index 0000000000..54e5b46486
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
@@ -0,0 +1,28 @@
+/** @import { AssignmentExpression } from 'estree' */
+/** @import { SvelteNode } from '#compiler' */
+/** @import { Context } from '../types' */
+import { extract_identifiers, object } from '../../../utils/ast.js';
+import { validate_assignment } from './shared/utils.js';
+
+/**
+ * @param {AssignmentExpression} node
+ * @param {Context} context
+ */
+export function AssignmentExpression(node, context) {
+	validate_assignment(node, node.left, context.state);
+
+	if (context.state.reactive_statement) {
+		const id = node.left.type === 'MemberExpression' ? object(node.left) : node.left;
+		if (id !== null) {
+			for (const id of extract_identifiers(node.left)) {
+				const binding = context.state.scope.get(id.name);
+
+				if (binding) {
+					context.state.reactive_statement.assignments.add(binding);
+				}
+			}
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Attribute.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Attribute.js
new file mode 100644
index 0000000000..86637b1944
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Attribute.js
@@ -0,0 +1,213 @@
+/** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression } from 'estree' */
+/** @import { Attribute, DelegatedEvent, RegularElement } from '#compiler' */
+/** @import { Context } from '../types' */
+import { DelegatedEvents, is_capture_event } from '../../../../constants.js';
+import {
+	get_attribute_chunks,
+	get_attribute_expression,
+	is_event_attribute
+} from '../../../utils/ast.js';
+
+/**
+ * @param {Attribute} node
+ * @param {Context} context
+ */
+export function Attribute(node, context) {
+	context.next();
+
+	if (node.value !== true) {
+		for (const chunk of get_attribute_chunks(node.value)) {
+			if (chunk.type !== 'ExpressionTag') continue;
+
+			if (
+				chunk.expression.type === 'FunctionExpression' ||
+				chunk.expression.type === 'ArrowFunctionExpression'
+			) {
+				continue;
+			}
+
+			node.metadata.expression.has_state ||= chunk.metadata.expression.has_state;
+			node.metadata.expression.has_call ||= chunk.metadata.expression.has_call;
+		}
+
+		if (is_event_attribute(node)) {
+			const parent = context.path.at(-1);
+			if (parent?.type === 'RegularElement' || parent?.type === 'SvelteElement') {
+				context.state.analysis.uses_event_attributes = true;
+			}
+
+			const expression = get_attribute_expression(node);
+			const delegated_event = get_delegated_event(node.name.slice(2), expression, context);
+
+			if (delegated_event !== null) {
+				if (delegated_event.type === 'hoistable') {
+					delegated_event.function.metadata.hoistable = true;
+				}
+
+				node.metadata.delegated = delegated_event;
+			}
+		}
+	}
+}
+
+/**
+ * Checks if given event attribute can be delegated/hoisted and returns the corresponding info if so
+ * @param {string} event_name
+ * @param {Expression | null} handler
+ * @param {Context} context
+ * @returns {null | DelegatedEvent}
+ */
+function get_delegated_event(event_name, handler, context) {
+	// Handle delegated event handlers. Bail-out if not a delegated event.
+	if (!handler || !DelegatedEvents.includes(event_name)) {
+		return null;
+	}
+
+	// If we are not working with a RegularElement, then bail-out.
+	const element = context.path.at(-1);
+	if (element?.type !== 'RegularElement') {
+		return null;
+	}
+
+	/** @type {DelegatedEvent} */
+	const non_hoistable = { type: 'non-hoistable' };
+	/** @type {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression | null} */
+	let target_function = null;
+	let binding = null;
+
+	if (element.metadata.has_spread) {
+		// event attribute becomes part of the dynamic spread array
+		return non_hoistable;
+	}
+
+	if (handler.type === 'ArrowFunctionExpression' || handler.type === 'FunctionExpression') {
+		target_function = handler;
+	} else if (handler.type === 'Identifier') {
+		binding = context.state.scope.get(handler.name);
+
+		if (context.state.analysis.module.scope.references.has(handler.name)) {
+			// If a binding with the same name is referenced in the module scope (even if not declared there), bail-out
+			return non_hoistable;
+		}
+
+		if (binding != null) {
+			for (const { path } of binding.references) {
+				const parent = path.at(-1);
+				if (parent == null) return non_hoistable;
+
+				const grandparent = path.at(-2);
+
+				/** @type {RegularElement | null} */
+				let element = null;
+				/** @type {string | null} */
+				let event_name = null;
+				if (parent.type === 'OnDirective') {
+					element = /** @type {RegularElement} */ (grandparent);
+					event_name = parent.name;
+				} else if (
+					parent.type === 'ExpressionTag' &&
+					grandparent?.type === 'Attribute' &&
+					is_event_attribute(grandparent)
+				) {
+					element = /** @type {RegularElement} */ (path.at(-3));
+					const attribute = /** @type {Attribute} */ (grandparent);
+					event_name = get_attribute_event_name(attribute.name);
+				}
+
+				if (element && event_name) {
+					if (
+						element.type !== 'RegularElement' ||
+						element.metadata.has_spread ||
+						!DelegatedEvents.includes(event_name)
+					) {
+						return non_hoistable;
+					}
+				} else if (parent.type !== 'FunctionDeclaration' && parent.type !== 'VariableDeclarator') {
+					return non_hoistable;
+				}
+			}
+		}
+
+		// If the binding is exported, bail-out
+		if (context.state.analysis.exports.find((node) => node.name === handler.name)) {
+			return non_hoistable;
+		}
+
+		if (binding !== null && binding.initial !== null && !binding.mutated && !binding.is_called) {
+			const binding_type = binding.initial.type;
+
+			if (
+				binding_type === 'ArrowFunctionExpression' ||
+				binding_type === 'FunctionDeclaration' ||
+				binding_type === 'FunctionExpression'
+			) {
+				target_function = binding.initial;
+			}
+		}
+	}
+
+	// If we can't find a function, bail-out
+	if (target_function == null) return non_hoistable;
+	// If the function is marked as non-hoistable, bail-out
+	if (target_function.metadata.hoistable === 'impossible') return non_hoistable;
+	// If the function has more than one arg, then bail-out
+	if (target_function.params.length > 1) return non_hoistable;
+
+	const visited_references = new Set();
+	const scope = target_function.metadata.scope;
+	for (const [reference] of scope.references) {
+		// Bail-out if the arguments keyword is used
+		if (reference === 'arguments') return non_hoistable;
+		// Bail-out if references a store subscription
+		if (scope.get(`$${reference}`)?.kind === 'store_sub') return non_hoistable;
+
+		const binding = scope.get(reference);
+		const local_binding = context.state.scope.get(reference);
+
+		// If we are referencing a binding that is shadowed in another scope then bail out.
+		if (local_binding !== null && binding !== null && local_binding.node !== binding.node) {
+			return non_hoistable;
+		}
+
+		// If we have multiple references to the same store using $ prefix, bail out.
+		if (
+			binding !== null &&
+			binding.kind === 'store_sub' &&
+			visited_references.has(reference.slice(1))
+		) {
+			return non_hoistable;
+		}
+
+		// If we reference the index within an each block, then bail-out.
+		if (binding !== null && binding.initial?.type === 'EachBlock') return non_hoistable;
+
+		if (
+			binding !== null &&
+			// Bail-out if the the binding is a rest param
+			(binding.declaration_kind === 'rest_param' ||
+				// Bail-out if we reference anything from the EachBlock (for now) that mutates in non-runes mode,
+				(((!context.state.analysis.runes && binding.kind === 'each') ||
+					// or any normal not reactive bindings that are mutated.
+					binding.kind === 'normal' ||
+					// or any reactive imports (those are rewritten) (can only happen in legacy mode)
+					binding.kind === 'legacy_reactive_import') &&
+					binding.mutated))
+		) {
+			return non_hoistable;
+		}
+		visited_references.add(reference);
+	}
+
+	return { type: 'hoistable', function: target_function };
+}
+
+/**
+ * @param {string} event_name
+ */
+function get_attribute_event_name(event_name) {
+	if (is_capture_event(event_name, 'include-on')) {
+		event_name = event_name.slice(0, -7);
+	}
+	event_name = event_name.slice(2);
+	return event_name;
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js
new file mode 100644
index 0000000000..a7d804c194
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js
@@ -0,0 +1,42 @@
+/** @import { AwaitBlock } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {AwaitBlock} node
+ * @param {Context} context
+ */
+export function AwaitBlock(node, context) {
+	validate_block_not_empty(node.pending, context);
+	validate_block_not_empty(node.then, context);
+	validate_block_not_empty(node.catch, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+
+		if (node.value) {
+			const start = /** @type {number} */ (node.value.start);
+			const match = context.state.analysis.source
+				.substring(start - 10, start)
+				.match(/{(\s*):then\s+$/);
+
+			if (match && match[1] !== '') {
+				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+			}
+		}
+
+		if (node.error) {
+			const start = /** @type {number} */ (node.error.start);
+			const match = context.state.analysis.source
+				.substring(start - 10, start)
+				.match(/{(\s*):catch\s+$/);
+
+			if (match && match[1] !== '') {
+				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+			}
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js
new file mode 100644
index 0000000000..183958afa4
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js
@@ -0,0 +1,234 @@
+/** @import { Attribute, BindDirective } from '#compiler' */
+/** @import { Context } from '../types' */
+import {
+	extract_all_identifiers_from_expression,
+	is_text_attribute,
+	object
+} from '../../../utils/ast.js';
+import { validate_no_const_assignment } from './shared/utils.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { binding_properties } from '../../bindings.js';
+import { ContentEditableBindings, SVGElements } from '../../constants.js';
+import fuzzymatch from '../../1-parse/utils/fuzzymatch.js';
+
+/**
+ * @param {BindDirective} node
+ * @param {Context} context
+ */
+export function BindDirective(node, context) {
+	validate_no_const_assignment(node, node.expression, context.state.scope, true);
+
+	const assignee = node.expression;
+	const left = object(assignee);
+
+	if (left === null) {
+		e.bind_invalid_expression(node);
+	}
+
+	const binding = context.state.scope.get(left.name);
+
+	if (assignee.type === 'Identifier') {
+		// reassignment
+		if (
+			node.name !== 'this' && // bind:this also works for regular variables
+			(!binding ||
+				(binding.kind !== 'state' &&
+					binding.kind !== 'frozen_state' &&
+					binding.kind !== 'prop' &&
+					binding.kind !== 'bindable_prop' &&
+					binding.kind !== 'each' &&
+					binding.kind !== 'store_sub' &&
+					!binding.mutated))
+		) {
+			e.bind_invalid_value(node.expression);
+		}
+
+		if (binding?.kind === 'derived') {
+			e.constant_binding(node.expression, 'derived state');
+		}
+
+		if (context.state.analysis.runes && binding?.kind === 'each') {
+			e.each_item_invalid_assignment(node);
+		}
+
+		if (binding?.kind === 'snippet') {
+			e.snippet_parameter_assignment(node);
+		}
+	}
+
+	if (node.name === 'group') {
+		if (!binding) {
+			throw new Error('Cannot find declaration for bind:group');
+		}
+
+		// Traverse the path upwards and find all EachBlocks who are (indirectly) contributing to bind:group,
+		// i.e. one of their declarations is referenced in the binding. This allows group bindings to work
+		// correctly when referencing a variable declared in an EachBlock by using the index of the each block
+		// entries as keys.
+		const each_blocks = [];
+		const [keypath, expression_ids] = extract_all_identifiers_from_expression(node.expression);
+		let ids = expression_ids;
+
+		let i = context.path.length;
+		while (i--) {
+			const parent = context.path[i];
+
+			if (parent.type === 'EachBlock') {
+				const references = ids.filter((id) => parent.metadata.declarations.has(id.name));
+
+				if (references.length > 0) {
+					parent.metadata.contains_group_binding = true;
+
+					for (const binding of parent.metadata.references) {
+						binding.mutated = true;
+					}
+
+					each_blocks.push(parent);
+					ids = ids.filter((id) => !references.includes(id));
+					ids.push(...extract_all_identifiers_from_expression(parent.expression)[1]);
+				}
+			}
+		}
+
+		// The identifiers that make up the binding expression form they key for the binding group.
+		// If the same identifiers in the same order are used in another bind:group, they will be in the same group.
+		// (there's an edge case where `bind:group={a[i]}` will be in a different group than `bind:group={a[j]}` even when i == j,
+		//  but this is a limitation of the current static analysis we do; it also never worked in Svelte 4)
+		const bindings = expression_ids.map((id) => context.state.scope.get(id.name));
+		let group_name;
+
+		outer: for (const [[key, b], group] of context.state.analysis.binding_groups) {
+			if (b.length !== bindings.length || key !== keypath) continue;
+			for (let i = 0; i < bindings.length; i++) {
+				if (bindings[i] !== b[i]) continue outer;
+			}
+			group_name = group;
+		}
+
+		if (!group_name) {
+			group_name = context.state.scope.root.unique('binding_group');
+			context.state.analysis.binding_groups.set([keypath, bindings], group_name);
+		}
+
+		node.metadata = {
+			binding_group_name: group_name,
+			parent_each_blocks: each_blocks
+		};
+	}
+
+	if (binding?.kind === 'each' && binding.metadata?.inside_rest) {
+		w.bind_invalid_each_rest(binding.node, binding.node.name);
+	}
+
+	const parent = context.path.at(-1);
+
+	if (
+		parent?.type === 'RegularElement' ||
+		parent?.type === 'SvelteElement' ||
+		parent?.type === 'SvelteWindow' ||
+		parent?.type === 'SvelteDocument' ||
+		parent?.type === 'SvelteBody'
+	) {
+		if (context.state.options.namespace === 'foreign' && node.name !== 'this') {
+			e.bind_invalid_name(node, node.name, 'Foreign elements only support `bind:this`');
+		}
+
+		if (node.name in binding_properties) {
+			const property = binding_properties[node.name];
+			if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
+				e.bind_invalid_target(
+					node,
+					node.name,
+					property.valid_elements.map((valid_element) => `<${valid_element}>`).join(', ')
+				);
+			}
+
+			if (property.invalid_elements && property.invalid_elements.includes(parent.name)) {
+				const valid_bindings = Object.entries(binding_properties)
+					.filter(([_, binding_property]) => {
+						return (
+							binding_property.valid_elements?.includes(parent.name) ||
+							(!binding_property.valid_elements &&
+								!binding_property.invalid_elements?.includes(parent.name))
+						);
+					})
+					.map(([property_name]) => property_name)
+					.sort();
+
+				e.bind_invalid_name(
+					node,
+					node.name,
+					`Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
+				);
+			}
+
+			if (parent.name === 'input' && node.name !== 'this') {
+				const type = /** @type {Attribute | undefined} */ (
+					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'type')
+				);
+
+				if (type && !is_text_attribute(type)) {
+					if (node.name !== 'value' || type.value === true) {
+						e.attribute_invalid_type(type);
+					}
+				} else {
+					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
+						e.bind_invalid_target(node, node.name, '<input type="checkbox">');
+					}
+
+					if (node.name === 'files' && type?.value[0].data !== 'file') {
+						e.bind_invalid_target(node, node.name, '<input type="file">');
+					}
+				}
+			}
+
+			if (parent.name === 'select' && node.name !== 'this') {
+				const multiple = parent.attributes.find(
+					(a) =>
+						a.type === 'Attribute' &&
+						a.name === 'multiple' &&
+						!is_text_attribute(a) &&
+						a.value !== true
+				);
+
+				if (multiple) {
+					e.attribute_invalid_multiple(multiple);
+				}
+			}
+
+			if (node.name === 'offsetWidth' && SVGElements.includes(parent.name)) {
+				e.bind_invalid_target(
+					node,
+					node.name,
+					`non-<svg> elements. Use 'clientWidth' for <svg> instead`
+				);
+			}
+
+			if (ContentEditableBindings.includes(node.name)) {
+				const contenteditable = /** @type {Attribute} */ (
+					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'contenteditable')
+				);
+
+				if (!contenteditable) {
+					e.attribute_contenteditable_missing(node);
+				} else if (!is_text_attribute(contenteditable) && contenteditable.value !== true) {
+					e.attribute_contenteditable_dynamic(contenteditable);
+				}
+			}
+		} else {
+			const match = fuzzymatch(node.name, Object.keys(binding_properties));
+
+			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, node.name);
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
new file mode 100644
index 0000000000..9d5a3ef5c1
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
@@ -0,0 +1,209 @@
+/** @import { CallExpression, VariableDeclarator } from 'estree' */
+/** @import { SvelteNode } from '#compiler' */
+/** @import { Context } from '../types' */
+import { get_rune } from '../../scope.js';
+import * as e from '../../../errors.js';
+import { get_parent, unwrap_optional } from '../../../utils/ast.js';
+import { is_safe_identifier } from './shared/utils.js';
+
+/**
+ * @param {CallExpression} node
+ * @param {Context} context
+ */
+export function CallExpression(node, context) {
+	const parent = /** @type {SvelteNode} */ (get_parent(context.path, -1));
+
+	const rune = get_rune(node, context.state.scope);
+
+	switch (rune) {
+		case null:
+			if (!is_safe_identifier(node.callee, context.state.scope)) {
+				context.state.analysis.needs_context = true;
+			}
+
+			break;
+
+		case '$bindable':
+			if (node.arguments.length > 1) {
+				e.rune_invalid_arguments_length(node, '$bindable', 'zero or one arguments');
+			}
+
+			if (
+				parent.type !== 'AssignmentPattern' ||
+				context.path.at(-3)?.type !== 'ObjectPattern' ||
+				context.path.at(-4)?.type !== 'VariableDeclarator' ||
+				get_rune(
+					/** @type {VariableDeclarator} */ (context.path.at(-4)).init,
+					context.state.scope
+				) !== '$props'
+			) {
+				e.bindable_invalid_location(node);
+			}
+
+			break;
+
+		case '$host':
+			if (node.arguments.length > 0) {
+				e.rune_invalid_arguments(node, '$host');
+			} else if (context.state.ast_type === 'module' || !context.state.analysis.custom_element) {
+				e.host_invalid_placement(node);
+			}
+
+			break;
+
+		case '$props':
+			if (context.state.has_props_rune) {
+				e.props_duplicate(node);
+			}
+
+			context.state.has_props_rune = true;
+
+			if (
+				parent.type !== 'VariableDeclarator' ||
+				context.state.ast_type !== 'instance' ||
+				context.state.scope !== context.state.analysis.instance.scope
+			) {
+				e.props_invalid_placement(node);
+			}
+
+			if (node.arguments.length > 0) {
+				e.rune_invalid_arguments(node, rune);
+			}
+
+			break;
+
+		case '$state':
+		case '$state.frozen':
+		case '$derived':
+		case '$derived.by':
+			if (
+				parent.type !== 'VariableDeclarator' &&
+				!(parent.type === 'PropertyDefinition' && !parent.static && !parent.computed)
+			) {
+				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');
+			} else if (rune === '$state' && node.arguments.length > 1) {
+				e.rune_invalid_arguments_length(node, rune, 'zero or one arguments');
+			}
+
+			break;
+
+		case '$effect':
+		case '$effect.pre':
+			if (parent.type !== 'ExpressionStatement') {
+				e.effect_invalid_placement(node);
+			}
+
+			if (node.arguments.length !== 1) {
+				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+			}
+
+			// `$effect` needs context because Svelte needs to know whether it should re-run
+			// effects that invalidate themselves, and that's determined by whether we're in runes mode
+			context.state.analysis.needs_context = true;
+
+			break;
+
+		case '$effect.tracking':
+			if (node.arguments.length !== 0) {
+				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');
+			}
+
+			break;
+
+		case '$inspect':
+			if (node.arguments.length < 1) {
+				e.rune_invalid_arguments_length(node, rune, 'one or more arguments');
+			}
+
+			break;
+
+		case '$inspect().with':
+			if (node.arguments.length !== 1) {
+				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+			}
+
+			break;
+
+		case '$state.snapshot':
+			if (node.arguments.length !== 1) {
+				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+			}
+
+			break;
+
+		case '$state.is':
+			if (node.arguments.length !== 2) {
+				e.rune_invalid_arguments_length(node, rune, 'exactly two arguments');
+			}
+
+			break;
+	}
+
+	if (context.state.expression && !is_known_safe_call(node, context)) {
+		context.state.expression.has_call = true;
+		context.state.expression.has_state = true;
+	}
+
+	if (context.state.render_tag) {
+		// Find out which of the render tag arguments contains this call expression
+		const arg_idx = unwrap_optional(context.state.render_tag.expression).arguments.findIndex(
+			(arg) => arg === node || context.path.includes(arg)
+		);
+
+		// -1 if this is the call expression of the render tag itself
+		if (arg_idx !== -1) {
+			context.state.render_tag.metadata.args_with_call_expression.add(arg_idx);
+		}
+	}
+
+	if (node.callee.type === 'Identifier') {
+		const binding = context.state.scope.get(node.callee.name);
+
+		if (binding !== null) {
+			binding.is_called = true;
+		}
+	}
+
+	// `$inspect(foo)` or `$derived(foo) should not trigger the `static-state-reference` warning
+	if (rune === '$inspect' || rune === '$derived') {
+		context.next({ ...context.state, function_depth: context.state.function_depth + 1 });
+	} else {
+		context.next();
+	}
+}
+
+/**
+ * @param {CallExpression} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function is_known_safe_call(node, context) {
+	const callee = node.callee;
+
+	// String / Number / BigInt / Boolean casting calls
+	if (callee.type === 'Identifier') {
+		const name = callee.name;
+		const binding = context.state.scope.get(name);
+		if (
+			binding === null &&
+			(name === 'BigInt' || name === 'String' || name === 'Number' || name === 'Boolean')
+		) {
+			return true;
+		}
+	}
+
+	// TODO add more cases
+
+	return false;
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
new file mode 100644
index 0000000000..d445af0ebf
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
@@ -0,0 +1,27 @@
+/** @import { ClassBody } from 'estree' */
+/** @import { Context } from '../types' */
+import { get_rune } from '../../scope.js';
+
+/**
+ * @param {ClassBody} node
+ * @param {Context} context
+ */
+export function ClassBody(node, context) {
+	/** @type {string[]} */
+	const private_derived_state = [];
+
+	for (const definition of node.body) {
+		if (
+			definition.type === 'PropertyDefinition' &&
+			definition.key.type === 'PrivateIdentifier' &&
+			definition.value?.type === 'CallExpression'
+		) {
+			const rune = get_rune(definition.value, context.state.scope);
+			if (rune === '$derived' || rune === '$derived.by') {
+				private_derived_state.push(definition.key.name);
+			}
+		}
+	}
+
+	context.next({ ...context.state, private_derived_state });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDeclaration.js
new file mode 100644
index 0000000000..49be955eba
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDeclaration.js
@@ -0,0 +1,20 @@
+/** @import { ClassDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {ClassDeclaration} node
+ * @param {Context} context
+ */
+export function ClassDeclaration(node, context) {
+	// In modules, we allow top-level module scope only, in components, we allow the component scope,
+	// which is function_depth of 1. With the exception of `new class` which is also not allowed at
+	// component scope level either.
+	const allowed_depth = context.state.ast_type === 'module' ? 0 : 1;
+
+	if (context.state.scope.function_depth > allowed_depth) {
+		w.perf_avoid_nested_class(node);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDirective.js
new file mode 100644
index 0000000000..ef87b3cbcf
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDirective.js
@@ -0,0 +1,10 @@
+/** @import { ClassDirective } from '#compiler' */
+/** @import { Context } from '../types' */
+
+/**
+ * @param {ClassDirective} node
+ * @param {Context} context
+ */
+export function ClassDirective(node, context) {
+	context.next({ ...context.state, expression: node.metadata.expression });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Component.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Component.js
new file mode 100644
index 0000000000..ea5a719b92
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Component.js
@@ -0,0 +1,20 @@
+/** @import { Component } from '#compiler' */
+/** @import { Context } from '../types' */
+import { visit_component } from './shared/component.js';
+
+/**
+ * @param {Component} node
+ * @param {Context} context
+ */
+export function Component(node, context) {
+	const binding = context.state.scope.get(
+		node.name.includes('.') ? node.name.slice(0, node.name.indexOf('.')) : node.name
+	);
+
+	node.metadata.dynamic =
+		context.state.analysis.runes && // Svelte 4 required you to use svelte:component to switch components
+		binding !== null &&
+		(binding.kind !== 'normal' || node.name.includes('.'));
+
+	visit_component(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ConstTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ConstTag.js
new file mode 100644
index 0000000000..3045688a08
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ConstTag.js
@@ -0,0 +1,34 @@
+/** @import { ConstTag } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {ConstTag} node
+ * @param {Context} context
+ */
+export function ConstTag(node, context) {
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '@');
+	}
+
+	const parent = context.path.at(-1);
+	const grand_parent = context.path.at(-2);
+
+	if (
+		parent?.type !== 'Fragment' ||
+		(grand_parent?.type !== 'IfBlock' &&
+			grand_parent?.type !== 'SvelteFragment' &&
+			grand_parent?.type !== 'Component' &&
+			grand_parent?.type !== 'SvelteComponent' &&
+			grand_parent?.type !== 'EachBlock' &&
+			grand_parent?.type !== 'AwaitBlock' &&
+			grand_parent?.type !== 'SnippetBlock' &&
+			((grand_parent?.type !== 'RegularElement' && grand_parent?.type !== 'SvelteElement') ||
+				!grand_parent.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')))
+	) {
+		e.const_tag_invalid_placement(node);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/DebugTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/DebugTag.js
new file mode 100644
index 0000000000..4f5e6c10d0
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/DebugTag.js
@@ -0,0 +1,15 @@
+/** @import { DebugTag } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {DebugTag} node
+ * @param {Context} context
+ */
+export function DebugTag(node, context) {
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '@');
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js
new file mode 100644
index 0000000000..2e09c756e3
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js
@@ -0,0 +1,29 @@
+/** @import { EachBlock } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {EachBlock} node
+ * @param {Context} context
+ */
+export function EachBlock(node, context) {
+	validate_opening_tag(node, context.state, '#');
+
+	validate_block_not_empty(node.body, context);
+	validate_block_not_empty(node.fallback, 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);
+	}
+
+	if (node.key) {
+		// treat `{#each items as item, i (i)}` as a normal indexed block, everything else as keyed
+		node.metadata.keyed =
+			node.key.type !== 'Identifier' || !node.index || node.key.name !== node.index;
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportDefaultDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportDefaultDeclaration.js
new file mode 100644
index 0000000000..0a7461f155
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportDefaultDeclaration.js
@@ -0,0 +1,15 @@
+/** @import { ExportDefaultDeclaration, Node } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {ExportDefaultDeclaration} node
+ * @param {Context} context
+ */
+export function ExportDefaultDeclaration(node, context) {
+	if (context.state.ast_type === 'instance') {
+		e.module_illegal_default_export(node);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js
new file mode 100644
index 0000000000..694c047b9c
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js
@@ -0,0 +1,92 @@
+/** @import { ExportNamedDeclaration, Identifier, Node } from 'estree' */
+/** @import { Binding } from '#compiler' */
+/** @import { Context } from '../types' */
+/** @import { Scope } from '../../scope' */
+import * as e from '../../../errors.js';
+import { extract_identifiers } from '../../../utils/ast.js';
+
+/**
+ * @param {ExportNamedDeclaration} node
+ * @param {Context} context
+ */
+export function ExportNamedDeclaration(node, context) {
+	// visit children, so bindings are correctly initialised
+	context.next();
+
+	if (node.declaration?.type === 'VariableDeclaration') {
+		// in runes mode, forbid `export let`
+		if (
+			context.state.analysis.runes &&
+			context.state.ast_type === 'instance' &&
+			node.declaration.kind === 'let'
+		) {
+			e.legacy_export_invalid(node);
+		}
+
+		for (const declarator of node.declaration.declarations) {
+			for (const id of extract_identifiers(declarator.id)) {
+				const binding = context.state.scope.get(id.name);
+				if (!binding) continue;
+
+				if (binding.kind === 'derived') {
+					e.derived_invalid_export(node);
+				}
+
+				if ((binding.kind === 'state' || binding.kind === 'frozen_state') && binding.reassigned) {
+					e.state_invalid_export(node);
+				}
+			}
+		}
+	}
+
+	if (context.state.ast_type === 'instance' && !context.state.analysis.runes) {
+		context.state.analysis.needs_props = true;
+
+		if (node.declaration) {
+			if (
+				node.declaration.type === 'FunctionDeclaration' ||
+				node.declaration.type === 'ClassDeclaration'
+			) {
+				context.state.analysis.exports.push({
+					name: /** @type {Identifier} */ (node.declaration.id).name,
+					alias: null
+				});
+			} else if (node.declaration.type === 'VariableDeclaration') {
+				if (node.declaration.kind === 'const') {
+					for (const declarator of node.declaration.declarations) {
+						for (const node of extract_identifiers(declarator.id)) {
+							context.state.analysis.exports.push({ name: node.name, alias: null });
+						}
+					}
+				} else {
+					for (const declarator of node.declaration.declarations) {
+						for (const id of extract_identifiers(declarator.id)) {
+							const binding = /** @type {Binding} */ (context.state.scope.get(id.name));
+							binding.kind = 'bindable_prop';
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (context.state.analysis.runes) {
+		if (node.declaration && context.state.ast_type === 'instance') {
+			if (
+				node.declaration.type === 'FunctionDeclaration' ||
+				node.declaration.type === 'ClassDeclaration'
+			) {
+				context.state.analysis.exports.push({
+					name: /** @type {Identifier} */ (node.declaration.id).name,
+					alias: null
+				});
+			} else if (node.declaration.kind === 'const') {
+				for (const declarator of node.declaration.declarations) {
+					for (const node of extract_identifiers(declarator.id)) {
+						context.state.analysis.exports.push({ name: node.name, alias: null });
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportSpecifier.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportSpecifier.js
new file mode 100644
index 0000000000..4660a450d6
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportSpecifier.js
@@ -0,0 +1,66 @@
+/** @import { ExportSpecifier, Node } from 'estree' */
+/** @import { Binding } from '#compiler' */
+/** @import { Context } from '../types' */
+/** @import { Scope } from '../../scope' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {ExportSpecifier} node
+ * @param {Context} context
+ */
+export function ExportSpecifier(node, context) {
+	if (context.state.ast_type === 'instance') {
+		if (context.state.analysis.runes) {
+			context.state.analysis.exports.push({
+				name: node.local.name,
+				alias: node.exported.name
+			});
+
+			const binding = context.state.scope.get(node.local.name);
+			if (binding) binding.reassigned = true;
+		} else {
+			context.state.analysis.needs_props = true;
+
+			const binding = /** @type {Binding} */ (context.state.scope.get(node.local.name));
+
+			if (
+				binding !== null &&
+				(binding.kind === 'state' ||
+					binding.kind === 'frozen_state' ||
+					(binding.kind === 'normal' &&
+						(binding.declaration_kind === 'let' || binding.declaration_kind === 'var')))
+			) {
+				binding.kind = 'bindable_prop';
+				if (node.exported.name !== node.local.name) {
+					binding.prop_alias = node.exported.name;
+				}
+			} else {
+				context.state.analysis.exports.push({
+					name: node.local.name,
+					alias: node.exported.name
+				});
+			}
+		}
+	} else {
+		validate_export(node, context.state.scope, node.local.name);
+	}
+}
+
+/**
+ *
+ * @param {Node} node
+ * @param {Scope} scope
+ * @param {string} name
+ */
+function validate_export(node, scope, name) {
+	const binding = scope.get(name);
+	if (!binding) return;
+
+	if (binding.kind === 'derived') {
+		e.derived_invalid_export(node);
+	}
+
+	if ((binding.kind === 'state' || binding.kind === 'frozen_state') && binding.reassigned) {
+		e.state_invalid_export(node);
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionStatement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionStatement.js
new file mode 100644
index 0000000000..afb4913bfb
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionStatement.js
@@ -0,0 +1,38 @@
+/** @import { ExpressionStatement, ImportDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {ExpressionStatement} node
+ * @param {Context} context
+ */
+export function ExpressionStatement(node, context) {
+	// warn on `new Component({ target: ... })` if imported from a `.svelte` file
+	if (
+		node.expression.type === 'NewExpression' &&
+		node.expression.callee.type === 'Identifier' &&
+		node.expression.arguments.length === 1 &&
+		node.expression.arguments[0].type === 'ObjectExpression' &&
+		node.expression.arguments[0].properties.some(
+			(p) => p.type === 'Property' && p.key.type === 'Identifier' && p.key.name === 'target'
+		)
+	) {
+		const binding = context.state.scope.get(node.expression.callee.name);
+
+		if (binding?.kind === 'normal' && binding.declaration_kind === 'import') {
+			const declaration = /** @type {ImportDeclaration} */ (binding.initial);
+
+			// Theoretically someone could import a class from a `.svelte.js` module, but that's too rare to worry about
+			if (
+				/** @type {string} */ (declaration.source.value).endsWith('.svelte') &&
+				declaration.specifiers.find(
+					(s) => s.local.name === binding.node.name && s.type === 'ImportDefaultSpecifier'
+				)
+			) {
+				w.legacy_component_creation(node.expression);
+			}
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js
new file mode 100644
index 0000000000..813f9f0905
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js
@@ -0,0 +1,18 @@
+/** @import { ExpressionTag } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_tag_valid_with_parent } from '../../../../html-tree-validation.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {ExpressionTag} node
+ * @param {Context} context
+ */
+export function ExpressionTag(node, context) {
+	if (node.parent && context.state.parent_element) {
+		if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
+			e.node_invalid_placement(node, '`{expression}`', context.state.parent_element);
+		}
+	}
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionDeclaration.js
new file mode 100644
index 0000000000..6d7074628e
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionDeclaration.js
@@ -0,0 +1,11 @@
+/** @import { FunctionDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import { visit_function } from './shared/function.js';
+
+/**
+ * @param {FunctionDeclaration} node
+ * @param {Context} context
+ */
+export function FunctionDeclaration(node, context) {
+	visit_function(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionExpression.js
new file mode 100644
index 0000000000..2c6db9c5b0
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/FunctionExpression.js
@@ -0,0 +1,11 @@
+/** @import { FunctionExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { visit_function } from './shared/function.js';
+
+/**
+ * @param {FunctionExpression} node
+ * @param {Context} context
+ */
+export function FunctionExpression(node, context) {
+	visit_function(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/HtmlTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/HtmlTag.js
new file mode 100644
index 0000000000..ecac6446ae
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/HtmlTag.js
@@ -0,0 +1,15 @@
+/** @import { HtmlTag } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {HtmlTag} node
+ * @param {Context} context
+ */
+export function HtmlTag(node, context) {
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '@');
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js
new file mode 100644
index 0000000000..2f586c9207
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js
@@ -0,0 +1,154 @@
+/** @import { Expression, Identifier } from 'estree' */
+/** @import { SvelteNode } from '#compiler' */
+/** @import { Context } from '../types' */
+import is_reference from 'is-reference';
+import { Runes } from '../../constants.js';
+import { should_proxy_or_freeze } from '../../3-transform/client/utils.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {Identifier} node
+ * @param {Context} context
+ */
+export function Identifier(node, context) {
+	let i = context.path.length;
+	let parent = /** @type {Expression} */ (context.path[--i]);
+
+	if (!is_reference(node, parent)) {
+		return;
+	}
+
+	// If we are using arguments outside of a function, then throw an error
+	if (
+		node.name === 'arguments' &&
+		!context.path.some((n) => n.type === 'FunctionDeclaration' || n.type === 'FunctionExpression')
+	) {
+		e.invalid_arguments_usage(node);
+	}
+
+	// `$$slots` exists even in runes mode
+	if (node.name === '$$slots') {
+		context.state.analysis.uses_slots = true;
+	}
+
+	if (context.state.analysis.runes) {
+		if (
+			Runes.includes(/** @type {Runes[number]} */ (node.name)) &&
+			context.state.scope.get(node.name) === null &&
+			context.state.scope.get(node.name.slice(1)) === null
+		) {
+			/** @type {Expression} */
+			let current = node;
+			let name = node.name;
+
+			while (parent.type === 'MemberExpression') {
+				if (parent.computed) e.rune_invalid_computed_property(parent);
+				name += `.${/** @type {Identifier} */ (parent.property).name}`;
+
+				current = parent;
+				parent = /** @type {Expression} */ (context.path[--i]);
+
+				if (!Runes.includes(/** @type {Runes[number]} */ (name))) {
+					if (name === '$effect.active') {
+						e.rune_renamed(parent, '$effect.active', '$effect.tracking');
+					}
+
+					e.rune_invalid_name(parent, name);
+				}
+			}
+
+			if (parent.type !== 'CallExpression') {
+				e.rune_missing_parentheses(current);
+			}
+		}
+	}
+
+	let binding = context.state.scope.get(node.name);
+
+	if (!context.state.analysis.runes) {
+		if (node.name === '$$props') {
+			context.state.analysis.uses_props = true;
+		}
+
+		if (node.name === '$$restProps') {
+			context.state.analysis.uses_rest_props = true;
+		}
+
+		if (
+			binding?.kind === 'normal' &&
+			((binding.scope === context.state.instance_scope &&
+				binding.declaration_kind !== 'function') ||
+				binding.declaration_kind === 'import')
+		) {
+			if (binding.declaration_kind === 'import') {
+				if (
+					binding.mutated &&
+					// TODO could be more fine-grained - not every mention in the template implies a state binding
+					(context.state.reactive_statement || context.state.ast_type === 'template') &&
+					parent.type === 'MemberExpression'
+				) {
+					binding.kind = 'legacy_reactive_import';
+				}
+			} else if (
+				binding.mutated &&
+				// TODO could be more fine-grained - not every mention in the template implies a state binding
+				(context.state.reactive_statement || context.state.ast_type === 'template')
+			) {
+				binding.kind = 'state';
+			} else if (
+				context.state.reactive_statement &&
+				parent.type === 'AssignmentExpression' &&
+				parent.left === binding.node
+			) {
+				binding.kind = 'derived';
+			}
+		} else if (binding?.kind === 'each' && binding.mutated) {
+			// Ensure that the array is marked as reactive even when only its entries are mutated
+			let i = context.path.length;
+			while (i--) {
+				const ancestor = context.path[i];
+				if (
+					ancestor.type === 'EachBlock' &&
+					context.state.analysis.template.scopes.get(ancestor)?.declarations.get(node.name) ===
+						binding
+				) {
+					for (const binding of ancestor.metadata.references) {
+						if (binding.kind === 'normal') {
+							binding.kind = 'state';
+						}
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	if (binding && binding.kind !== 'normal') {
+		if (context.state.expression) {
+			context.state.expression.dependencies.add(binding);
+			context.state.expression.has_state = true;
+		}
+
+		if (
+			context.state.analysis.runes &&
+			node !== binding.node &&
+			context.state.function_depth === binding.scope.function_depth &&
+			// If we have $state that can be proxied or frozen and isn't re-assigned, then that means
+			// it's likely not using a primitive value and thus this warning isn't that helpful.
+			((binding.kind === 'state' &&
+				(binding.reassigned ||
+					(binding.initial?.type === 'CallExpression' &&
+						binding.initial.arguments.length === 1 &&
+						binding.initial.arguments[0].type !== 'SpreadElement' &&
+						!should_proxy_or_freeze(binding.initial.arguments[0], context.state.scope)))) ||
+				binding.kind === 'frozen_state' ||
+				binding.kind === 'derived') &&
+			// We're only concerned with reads here
+			(parent.type !== 'AssignmentExpression' || parent.left !== node) &&
+			parent.type !== 'UpdateExpression'
+		) {
+			w.state_referenced_locally(node);
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/IfBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/IfBlock.js
new file mode 100644
index 0000000000..f7b6641c44
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/IfBlock.js
@@ -0,0 +1,26 @@
+/** @import { IfBlock } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {IfBlock} node
+ * @param {Context} context
+ */
+export function IfBlock(node, context) {
+	validate_block_not_empty(node.consequent, context);
+	validate_block_not_empty(node.alternate, context);
+
+	if (context.state.analysis.runes) {
+		const parent = context.path.at(-1);
+		const expected =
+			context.path.at(-2)?.type === 'IfBlock' &&
+			parent?.type === 'Fragment' &&
+			parent.nodes.length === 1
+				? ':'
+				: '#';
+
+		validate_opening_tag(node, context.state, expected);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js
new file mode 100644
index 0000000000..eb57fee264
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js
@@ -0,0 +1,30 @@
+/** @import { ImportDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {ImportDeclaration} node
+ * @param {Context} context
+ */
+export function ImportDeclaration(node, context) {
+	if (context.state.analysis.runes) {
+		const source = /** @type {string} */ (node.source.value);
+
+		if (source.startsWith('svelte/internal')) {
+			e.import_svelte_internal_forbidden(node);
+		}
+
+		if (source === 'svelte') {
+			for (const specifier of node.specifiers) {
+				if (specifier.type === 'ImportSpecifier') {
+					if (
+						specifier.imported.name === 'beforeUpdate' ||
+						specifier.imported.name === 'afterUpdate'
+					) {
+						e.runes_mode_invalid_import(specifier, specifier.imported.name);
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/KeyBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/KeyBlock.js
new file mode 100644
index 0000000000..618ce41493
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/KeyBlock.js
@@ -0,0 +1,17 @@
+/** @import { KeyBlock } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {KeyBlock} node
+ * @param {Context} context
+ */
+export function KeyBlock(node, context) {
+	validate_block_not_empty(node.fragment, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/LabeledStatement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/LabeledStatement.js
new file mode 100644
index 0000000000..9be8c161d4
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/LabeledStatement.js
@@ -0,0 +1,104 @@
+/** @import { Expression, LabeledStatement } from 'estree' */
+/** @import { ReactiveStatement, SvelteNode } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { extract_identifiers, object } from '../../../utils/ast.js';
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {LabeledStatement} node
+ * @param {Context} context
+ */
+export function LabeledStatement(node, context) {
+	if (node.label.name === '$') {
+		const parent = /** @type {SvelteNode} */ (context.path.at(-1));
+
+		const is_reactive_statement =
+			context.state.ast_type === 'instance' && parent.type === 'Program';
+
+		if (is_reactive_statement) {
+			if (context.state.analysis.runes) {
+				e.legacy_reactive_statement_invalid(node);
+			}
+
+			// Find all dependencies of this `$: {...}` statement
+			/** @type {ReactiveStatement} */
+			const reactive_statement = {
+				assignments: new Set(),
+				dependencies: []
+			};
+
+			context.next({
+				...context.state,
+				reactive_statement,
+				function_depth: context.state.scope.function_depth + 1
+			});
+
+			// Every referenced binding becomes a dependency, unless it's on
+			// the left-hand side of an `=` assignment
+			for (const [name, nodes] of context.state.scope.references) {
+				const binding = context.state.scope.get(name);
+				if (binding === null) continue;
+
+				for (const { node, path } of nodes) {
+					/** @type {Expression} */
+					let left = node;
+
+					let i = path.length - 1;
+					let parent = /** @type {Expression} */ (path.at(i));
+					while (parent.type === 'MemberExpression') {
+						left = parent;
+						parent = /** @type {Expression} */ (path.at(--i));
+					}
+
+					if (
+						parent.type === 'AssignmentExpression' &&
+						parent.operator === '=' &&
+						parent.left === left
+					) {
+						continue;
+					}
+
+					reactive_statement.dependencies.push(binding);
+					break;
+				}
+			}
+
+			context.state.reactive_statements.set(node, reactive_statement);
+
+			if (
+				reactive_statement.dependencies.length &&
+				reactive_statement.dependencies.every(
+					(d) => d.scope === context.state.analysis.module.scope && d.declaration_kind !== 'const'
+				)
+			) {
+				w.reactive_declaration_module_script(node);
+			}
+
+			if (
+				node.body.type === 'ExpressionStatement' &&
+				node.body.expression.type === 'AssignmentExpression'
+			) {
+				let ids = extract_identifiers(node.body.expression.left);
+				if (node.body.expression.left.type === 'MemberExpression') {
+					const id = object(node.body.expression.left);
+					if (id !== null) {
+						ids = [id];
+					}
+				}
+
+				for (const id of ids) {
+					const binding = context.state.scope.get(id.name);
+					if (binding?.kind === 'legacy_reactive') {
+						// TODO does this include `let double; $: double = x * 2`?
+						binding.legacy_dependencies = Array.from(reactive_statement.dependencies);
+					}
+				}
+			}
+		} else if (!context.state.analysis.runes) {
+			w.reactive_declaration_invalid_placement(node);
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js
new file mode 100644
index 0000000000..562b900411
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js
@@ -0,0 +1,24 @@
+/** @import { LetDirective } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {LetDirective} node
+ * @param {Context} context
+ */
+export function LetDirective(node, context) {
+	const parent = context.path.at(-1);
+
+	if (
+		parent === undefined ||
+		(parent.type !== 'Component' &&
+			parent.type !== 'RegularElement' &&
+			parent.type !== 'SlotElement' &&
+			parent.type !== 'SvelteElement' &&
+			parent.type !== 'SvelteComponent' &&
+			parent.type !== 'SvelteSelf' &&
+			parent.type !== 'SvelteFragment')
+	) {
+		e.let_directive_invalid_placement(node);
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/MemberExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/MemberExpression.js
new file mode 100644
index 0000000000..633275b63a
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/MemberExpression.js
@@ -0,0 +1,27 @@
+/** @import { MemberExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { is_safe_identifier } from './shared/utils.js';
+
+/**
+ * @param {MemberExpression} node
+ * @param {Context} context
+ */
+export function MemberExpression(node, context) {
+	if (node.object.type === 'Identifier' && node.property.type === 'Identifier') {
+		const binding = context.state.scope.get(node.object.name);
+		if (binding?.kind === 'rest_prop' && node.property.name.startsWith('$$')) {
+			e.props_illegal_name(node.property);
+		}
+	}
+
+	if (context.state.expression) {
+		context.state.expression.has_state = true;
+	}
+
+	if (!is_safe_identifier(node, context.state.scope)) {
+		context.state.analysis.needs_context = true;
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/NewExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/NewExpression.js
new file mode 100644
index 0000000000..6b393ae9b9
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/NewExpression.js
@@ -0,0 +1,15 @@
+/** @import { NewExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {NewExpression} node
+ * @param {Context} context
+ */
+export function NewExpression(node, context) {
+	if (node.callee.type === 'ClassExpression' && context.state.scope.function_depth > 0) {
+		w.perf_avoid_inline_class(node);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js
new file mode 100644
index 0000000000..152f8301aa
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js
@@ -0,0 +1,25 @@
+/** @import { OnDirective } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {OnDirective} node
+ * @param {Context} context
+ */
+export function OnDirective(node, context) {
+	if (context.state.analysis.runes) {
+		const parent_type = context.path.at(-1)?.type;
+
+		// 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);
+		}
+	}
+
+	const parent = context.path.at(-1);
+	if (parent?.type === 'SvelteElement' || parent?.type === 'RegularElement') {
+		context.state.analysis.event_directive_node ??= node;
+	}
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js
new file mode 100644
index 0000000000..3207919ada
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js
@@ -0,0 +1,164 @@
+/** @import { RegularElement } from '#compiler' */
+/** @import { Context } from '../types' */
+import {
+	is_tag_valid_with_ancestor,
+	is_tag_valid_with_parent
+} from '../../../../html-tree-validation.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { MathMLElements, SVGElements, VoidElements } from '../../constants.js';
+import { create_attribute } from '../../nodes.js';
+import { regex_starts_with_newline } from '../../patterns.js';
+import { check_element } from './shared/a11y.js';
+import { validate_element } from './shared/element.js';
+
+/**
+ * @param {RegularElement} node
+ * @param {Context} context
+ */
+export function RegularElement(node, context) {
+	validate_element(node, context);
+
+	check_element(node, context.state);
+
+	context.state.analysis.elements.push(node);
+
+	// Special case: Move the children of <textarea> into a value attribute if they are dynamic
+	if (
+		context.state.options.namespace !== 'foreign' &&
+		node.name === 'textarea' &&
+		node.fragment.nodes.length > 0
+	) {
+		for (const attribute of node.attributes) {
+			if (attribute.type === 'Attribute' && attribute.name === 'value') {
+				e.textarea_invalid_content(node);
+			}
+		}
+
+		if (node.fragment.nodes.length > 1 || node.fragment.nodes[0].type !== 'Text') {
+			const first = node.fragment.nodes[0];
+			if (first.type === 'Text') {
+				// The leading newline character needs to be stripped because of a qirk:
+				// It is ignored by browsers if the tag and its contents are set through
+				// innerHTML, but we're now setting it through the value property at which
+				// point it is _not_ ignored, so we need to strip it ourselves.
+				// see https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
+				// see https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element
+				first.data = first.data.replace(regex_starts_with_newline, '');
+				first.raw = first.raw.replace(regex_starts_with_newline, '');
+			}
+
+			node.attributes.push(
+				create_attribute(
+					'value',
+					/** @type {import('#compiler').Text} */ (node.fragment.nodes.at(0)).start,
+					/** @type {import('#compiler').Text} */ (node.fragment.nodes.at(-1)).end,
+					// @ts-ignore
+					node.fragment.nodes
+				)
+			);
+
+			node.fragment.nodes = [];
+		}
+	}
+
+	// Special case: single expression tag child of option element -> add "fake" attribute
+	// to ensure that value types are the same (else for example numbers would be strings)
+	if (
+		context.state.options.namespace !== 'foreign' &&
+		node.name === 'option' &&
+		node.fragment.nodes?.length === 1 &&
+		node.fragment.nodes[0].type === 'ExpressionTag' &&
+		!node.attributes.some(
+			(attribute) => attribute.type === 'Attribute' && attribute.name === 'value'
+		)
+	) {
+		const child = node.fragment.nodes[0];
+		node.attributes.push(create_attribute('value', child.start, child.end, [child]));
+	}
+
+	const binding = context.state.scope.get(node.name);
+	if (
+		binding !== null &&
+		binding.declaration_kind === 'import' &&
+		binding.references.length === 0
+	) {
+		w.component_name_lowercase(node, node.name);
+	}
+
+	node.metadata.has_spread = node.attributes.some(
+		(attribute) => attribute.type === 'SpreadAttribute'
+	);
+
+	if (context.state.options.namespace !== 'foreign') {
+		if (SVGElements.includes(node.name)) node.metadata.svg = true;
+		else if (MathMLElements.includes(node.name)) node.metadata.mathml = true;
+	}
+
+	if (context.state.parent_element) {
+		let past_parent = false;
+		let only_warn = false;
+
+		for (let i = context.path.length - 1; i >= 0; i--) {
+			const ancestor = context.path[i];
+
+			if (
+				ancestor.type === 'IfBlock' ||
+				ancestor.type === 'EachBlock' ||
+				ancestor.type === 'AwaitBlock' ||
+				ancestor.type === 'KeyBlock'
+			) {
+				// We're creating a separate template string inside blocks, which means client-side this would work
+				only_warn = true;
+			}
+
+			if (!past_parent) {
+				if (ancestor.type === 'RegularElement' && ancestor.name === context.state.parent_element) {
+					if (!is_tag_valid_with_parent(node.name, context.state.parent_element)) {
+						if (only_warn) {
+							w.node_invalid_placement_ssr(
+								node,
+								`\`<${node.name}>\``,
+								context.state.parent_element
+							);
+						} else {
+							e.node_invalid_placement(node, `\`<${node.name}>\``, context.state.parent_element);
+						}
+					}
+
+					past_parent = true;
+				}
+			} else if (ancestor.type === 'RegularElement') {
+				if (!is_tag_valid_with_ancestor(node.name, ancestor.name)) {
+					if (only_warn) {
+						w.node_invalid_placement_ssr(node, `\`<${node.name}>\``, ancestor.name);
+					} else {
+						e.node_invalid_placement(node, `\`<${node.name}>\``, ancestor.name);
+					}
+				}
+			} else if (
+				ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteElement' ||
+				ancestor.type === 'SvelteSelf' ||
+				ancestor.type === 'SnippetBlock'
+			) {
+				break;
+			}
+		}
+	}
+
+	// Strip off any namespace from the beginning of the node name.
+	const node_name = node.name.replace(/[a-zA-Z-]*:/g, '');
+
+	if (
+		context.state.analysis.source[node.end - 2] === '/' &&
+		context.state.options.namespace !== 'foreign' &&
+		!VoidElements.includes(node_name) &&
+		!SVGElements.includes(node_name)
+	) {
+		w.element_invalid_self_closing_tag(node, node.name);
+	}
+
+	context.next({ ...context.state, parent_element: node.name });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/RenderTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/RenderTag.js
new file mode 100644
index 0000000000..525eb72415
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/RenderTag.js
@@ -0,0 +1,37 @@
+/** @import { RenderTag } from '#compiler' */
+/** @import { Context } from '../types' */
+import { unwrap_optional } from '../../../utils/ast.js';
+import * as e from '../../../errors.js';
+import { validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {RenderTag} node
+ * @param {Context} context
+ */
+export function RenderTag(node, context) {
+	validate_opening_tag(node, context.state, '@');
+
+	const callee = unwrap_optional(node.expression).callee;
+
+	node.metadata.dynamic =
+		callee.type !== 'Identifier' || context.state.scope.get(callee.name)?.kind !== 'normal';
+
+	context.state.analysis.uses_render_tags = true;
+
+	const raw_args = unwrap_optional(node.expression).arguments;
+	for (const arg of raw_args) {
+		if (arg.type === 'SpreadElement') {
+			e.render_tag_invalid_spread_argument(arg);
+		}
+	}
+
+	if (
+		callee.type === 'MemberExpression' &&
+		callee.property.type === 'Identifier' &&
+		['bind', 'apply', 'call'].includes(callee.property.name)
+	) {
+		e.render_tag_invalid_call_expression(node);
+	}
+
+	context.next({ ...context.state, render_tag: node });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SlotElement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SlotElement.js
new file mode 100644
index 0000000000..7c2c0ecf6a
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SlotElement.js
@@ -0,0 +1,39 @@
+/** @import { SlotElement } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_text_attribute } from '../../../utils/ast.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {SlotElement} node
+ * @param {Context} context
+ */
+export function SlotElement(node, context) {
+	if (context.state.analysis.runes && !context.state.analysis.custom_element) {
+		w.slot_element_deprecated(node);
+	}
+
+	/** @type {string} */
+	let name = 'default';
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			if (attribute.name === 'name') {
+				if (!is_text_attribute(attribute)) {
+					e.slot_element_invalid_name(attribute);
+				}
+
+				name = attribute.value[0].data;
+				if (name === 'default') {
+					e.slot_element_invalid_name_default(attribute);
+				}
+			}
+		} else if (attribute.type !== 'SpreadAttribute' && attribute.type !== 'LetDirective') {
+			e.slot_element_invalid_attribute(attribute);
+		}
+	}
+
+	context.state.analysis.slot_names.set(name, node);
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
new file mode 100644
index 0000000000..8a81e67e0e
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
@@ -0,0 +1,55 @@
+/** @import { SnippetBlock } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {SnippetBlock} node
+ * @param {Context} context
+ */
+export function SnippetBlock(node, context) {
+	validate_block_not_empty(node.body, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+	}
+
+	for (const arg of node.parameters) {
+		if (arg.type === 'RestElement') {
+			e.snippet_invalid_rest_parameter(arg);
+		}
+	}
+
+	context.next({ ...context.state, parent_element: null });
+
+	const { path } = context;
+	const parent = path.at(-2);
+	if (!parent) return;
+
+	if (
+		parent.type === 'Component' &&
+		parent.attributes.some(
+			(attribute) =>
+				(attribute.type === 'Attribute' || attribute.type === 'BindDirective') &&
+				attribute.name === node.expression.name
+		)
+	) {
+		e.snippet_shadowing_prop(node, node.expression.name);
+	}
+
+	if (node.expression.name !== 'children') return;
+
+	if (
+		parent.type === 'Component' ||
+		parent.type === 'SvelteComponent' ||
+		parent.type === 'SvelteSelf'
+	) {
+		if (
+			parent.fragment.nodes.some(
+				(node) => node.type !== 'SnippetBlock' && (node.type !== 'Text' || node.data.trim())
+			)
+		) {
+			e.snippet_conflict(node);
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SpreadAttribute.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SpreadAttribute.js
new file mode 100644
index 0000000000..feac14bb9b
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SpreadAttribute.js
@@ -0,0 +1,10 @@
+/** @import { SpreadAttribute } from '#compiler' */
+/** @import { Context } from '../types' */
+
+/**
+ * @param {SpreadAttribute} node
+ * @param {Context} context
+ */
+export function SpreadAttribute(node, context) {
+	context.next({ ...context.state, expression: node.metadata.expression });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/StyleDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/StyleDirective.js
new file mode 100644
index 0000000000..288a9a61f4
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/StyleDirective.js
@@ -0,0 +1,38 @@
+/** @import { StyleDirective } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { get_attribute_chunks } from '../../../utils/ast.js';
+
+/**
+ * @param {StyleDirective} node
+ * @param {Context} context
+ */
+export function StyleDirective(node, context) {
+	if (node.modifiers.length > 1 || (node.modifiers.length && node.modifiers[0] !== 'important')) {
+		e.style_directive_invalid_modifier(node);
+	}
+
+	if (node.value === true) {
+		// get the binding for node.name and change the binding to state
+		let binding = context.state.scope.get(node.name);
+
+		if (binding) {
+			if (!context.state.analysis.runes && binding.mutated) {
+				binding.kind = 'state';
+			}
+
+			if (binding.kind !== 'normal') {
+				node.metadata.expression.has_state = true;
+			}
+		}
+	} else {
+		context.next();
+
+		for (const chunk of get_attribute_chunks(node.value)) {
+			if (chunk.type !== 'ExpressionTag') continue;
+
+			node.metadata.expression.has_state ||= chunk.metadata.expression.has_state;
+			node.metadata.expression.has_call ||= chunk.metadata.expression.has_call;
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteComponent.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteComponent.js
new file mode 100644
index 0000000000..97f78e9d85
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteComponent.js
@@ -0,0 +1,11 @@
+/** @import { SvelteComponent } from '#compiler' */
+/** @import { Context } from '../types' */
+import { visit_component } from './shared/component.js';
+
+/**
+ * @param {SvelteComponent} node
+ * @param {Context} context
+ */
+export function SvelteComponent(node, context) {
+	visit_component(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteElement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteElement.js
new file mode 100644
index 0000000000..df9e1da3a9
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteElement.js
@@ -0,0 +1,62 @@
+/** @import { Attribute, SvelteElement, Text } from '#compiler' */
+/** @import { Context } from '../types' */
+import { namespace_mathml, namespace_svg } from '../../../../constants.js';
+import { is_text_attribute } from '../../../utils/ast.js';
+import { check_element } from './shared/a11y.js';
+import { validate_element } from './shared/element.js';
+
+/**
+ * @param {SvelteElement} node
+ * @param {Context} context
+ */
+export function SvelteElement(node, context) {
+	validate_element(node, context);
+
+	check_element(node, context.state);
+
+	context.state.analysis.elements.push(node);
+
+	const xmlns = /** @type {Attribute & { value: [Text] } | undefined} */ (
+		node.attributes.find(
+			(a) => a.type === 'Attribute' && a.name === 'xmlns' && is_text_attribute(a)
+		)
+	);
+
+	if (xmlns) {
+		node.metadata.svg = xmlns.value[0].data === namespace_svg;
+		node.metadata.mathml = xmlns.value[0].data === namespace_mathml;
+	} else {
+		let i = context.path.length;
+		while (i--) {
+			const ancestor = context.path[i];
+
+			if (
+				ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteFragment' ||
+				ancestor.type === 'SnippetBlock'
+			) {
+				// Inside a slot or a snippet -> this resets the namespace, so assume the component namespace
+				node.metadata.svg = context.state.options.namespace === 'svg';
+				node.metadata.mathml = context.state.options.namespace === 'mathml';
+				break;
+			}
+
+			if (ancestor.type === 'SvelteElement' || ancestor.type === 'RegularElement') {
+				node.metadata.svg =
+					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
+						? false
+						: ancestor.metadata.svg;
+
+				node.metadata.mathml =
+					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
+						? false
+						: ancestor.metadata.mathml;
+
+				break;
+			}
+		}
+	}
+
+	context.next({ ...context.state, parent_element: null });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteFragment.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteFragment.js
new file mode 100644
index 0000000000..178414edea
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteFragment.js
@@ -0,0 +1,27 @@
+/** @import { SvelteFragment } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { validate_slot_attribute } from './shared/attribute.js';
+
+/**
+ * @param {SvelteFragment} node
+ * @param {Context} context
+ */
+export function SvelteFragment(node, context) {
+	const parent = context.path.at(-2);
+	if (parent?.type !== 'Component' && parent?.type !== 'SvelteComponent') {
+		e.svelte_fragment_invalid_placement(node);
+	}
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			if (attribute.name === 'slot') {
+				validate_slot_attribute(context, attribute);
+			}
+		} else if (attribute.type !== 'LetDirective') {
+			e.svelte_fragment_invalid_attribute(attribute);
+		}
+	}
+
+	context.next({ ...context.state, parent_element: null });
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteHead.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteHead.js
new file mode 100644
index 0000000000..713f7c4ca6
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteHead.js
@@ -0,0 +1,15 @@
+/** @import { SvelteHead } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {SvelteHead} node
+ * @param {Context} context
+ */
+export function SvelteHead(node, context) {
+	for (const attribute of node.attributes) {
+		e.svelte_head_illegal_attribute(attribute);
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js
new file mode 100644
index 0000000000..5b259bb636
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js
@@ -0,0 +1,11 @@
+/** @import { SvelteSelf } from '#compiler' */
+/** @import { Context } from '../types' */
+import { visit_component } from './shared/component.js';
+
+/**
+ * @param {SvelteSelf} node
+ * @param {Context} context
+ */
+export function SvelteSelf(node, context) {
+	visit_component(node, context);
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js
new file mode 100644
index 0000000000..e491042e38
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js
@@ -0,0 +1,17 @@
+/** @import { Text } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_tag_valid_with_parent } from '../../../../html-tree-validation.js';
+import { regex_not_whitespace } from '../../patterns.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {Text} node
+ * @param {Context} context
+ */
+export function Text(node, context) {
+	if (node.parent && context.state.parent_element && regex_not_whitespace.test(node.data)) {
+		if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
+			e.node_invalid_placement(node, 'Text node', context.state.parent_element);
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/TitleElement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/TitleElement.js
new file mode 100644
index 0000000000..628e254964
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/TitleElement.js
@@ -0,0 +1,21 @@
+/** @import { TitleElement } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {TitleElement} node
+ * @param {Context} context
+ */
+export function TitleElement(node, context) {
+	for (const attribute of node.attributes) {
+		e.title_illegal_attribute(attribute);
+	}
+
+	for (const child of node.fragment.nodes) {
+		if (child.type !== 'Text' && child.type !== 'ExpressionTag') {
+			e.title_invalid_content(child);
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/UpdateExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/UpdateExpression.js
new file mode 100644
index 0000000000..741effc67a
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/UpdateExpression.js
@@ -0,0 +1,25 @@
+/** @import { UpdateExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { object } from '../../../utils/ast.js';
+import { validate_assignment } from './shared/utils.js';
+
+/**
+ * @param {UpdateExpression} node
+ * @param {Context} context
+ */
+export function UpdateExpression(node, context) {
+	validate_assignment(node, node.argument, context.state);
+
+	if (context.state.reactive_statement) {
+		const id = node.argument.type === 'MemberExpression' ? object(node.argument) : node.argument;
+		if (id?.type === 'Identifier') {
+			const binding = context.state.scope.get(id.name);
+
+			if (binding) {
+				context.state.reactive_statement.assignments.add(binding);
+			}
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js
new file mode 100644
index 0000000000..5025fab1d8
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js
@@ -0,0 +1,115 @@
+/** @import { Expression, Identifier, Literal, VariableDeclarator } from 'estree' */
+/** @import { Binding } from '#compiler' */
+/** @import { Context } from '../types' */
+import { get_rune } from '../../scope.js';
+import { ensure_no_module_import_conflict } from './shared/utils.js';
+import * as e from '../../../errors.js';
+import { extract_paths } from '../../../utils/ast.js';
+import { equal } from '../../../utils/assert.js';
+
+/**
+ * @param {VariableDeclarator} node
+ * @param {Context} context
+ */
+export function VariableDeclarator(node, context) {
+	ensure_no_module_import_conflict(node, context.state);
+
+	if (context.state.analysis.runes) {
+		const init = node.init;
+		const rune = get_rune(init, context.state.scope);
+
+		// TODO feels like this should happen during scope creation?
+		if (
+			rune === '$state' ||
+			rune === '$state.frozen' ||
+			rune === '$derived' ||
+			rune === '$derived.by' ||
+			rune === '$props'
+		) {
+			for (const path of extract_paths(node.id)) {
+				// @ts-ignore this fails in CI for some insane reason
+				const binding = /** @type {Binding} */ (context.state.scope.get(path.node.name));
+				binding.kind =
+					rune === '$state'
+						? 'state'
+						: rune === '$state.frozen'
+							? 'frozen_state'
+							: rune === '$derived' || rune === '$derived.by'
+								? 'derived'
+								: path.is_rest
+									? 'rest_prop'
+									: 'prop';
+			}
+		}
+
+		if (rune === '$props') {
+			if (node.id.type !== 'ObjectPattern' && node.id.type !== 'Identifier') {
+				e.props_invalid_identifier(node);
+			}
+
+			context.state.analysis.needs_props = true;
+
+			if (node.id.type === 'Identifier') {
+				const binding = /** @type {Binding} */ (context.state.scope.get(node.id.name));
+				binding.initial = null; // else would be $props()
+				binding.kind = 'rest_prop';
+			} else {
+				equal(node.id.type, 'ObjectPattern');
+
+				for (const property of node.id.properties) {
+					if (property.type !== 'Property') continue;
+
+					if (property.computed) {
+						e.props_invalid_pattern(property);
+					}
+
+					if (property.key.type === 'Identifier' && property.key.name.startsWith('$$')) {
+						e.props_illegal_name(property);
+					}
+
+					const value =
+						property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
+
+					if (value.type !== 'Identifier') {
+						e.props_invalid_pattern(property);
+					}
+
+					const alias =
+						property.key.type === 'Identifier'
+							? property.key.name
+							: String(/** @type {Literal} */ (property.key).value);
+
+					let initial = property.value.type === 'AssignmentPattern' ? property.value.right : null;
+
+					const binding = /** @type {Binding} */ (context.state.scope.get(value.name));
+					binding.prop_alias = alias;
+
+					// rewire initial from $props() to the actual initial value, stripping $bindable() if necessary
+					if (
+						initial?.type === 'CallExpression' &&
+						initial.callee.type === 'Identifier' &&
+						initial.callee.name === '$bindable'
+					) {
+						binding.initial = /** @type {Expression | null} */ (initial.arguments[0] ?? null);
+						binding.kind = 'bindable_prop';
+					} else {
+						binding.initial = initial;
+					}
+				}
+			}
+		}
+	} else {
+		if (node.init?.type === 'CallExpression') {
+			const callee = node.init.callee;
+			if (
+				callee.type === 'Identifier' &&
+				(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);
+			}
+		}
+	}
+
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/a11y.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y.js
similarity index 98%
rename from packages/svelte/src/compiler/phases/2-analyze/a11y.js
rename to packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y.js
index 4a8882b45d..0d83e12de4 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/a11y.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y.js
@@ -1,5 +1,5 @@
 /** @import { Visitors } from 'zimmerframe' */
-/** @import { AnalysisState } from './types.js' */
+/** @import { AnalysisState } from '../../types.js' */
 /** @import { Attribute, SvelteNode, TemplateNode, RegularElement, SvelteElement } from '#compiler' */
 /** @import { ARIARoleDefinitionKey, ARIARoleRelationConcept, ARIAProperty, ARIAPropertyDefinition, ARIARoleDefinition } from 'aria-query' */
 import { roles as roles_map, aria, elementRoles } from 'aria-query';
@@ -10,13 +10,13 @@ import {
 	regex_not_whitespace,
 	regex_starts_with_vowel,
 	regex_whitespaces
-} from '../patterns.js';
-import * as w from '../../warnings.js';
-import fuzzymatch from '../1-parse/utils/fuzzymatch.js';
-import { is_event_attribute, is_text_attribute } from '../../utils/ast.js';
-import { ContentEditableBindings } from '../constants.js';
+} from '../../../patterns.js';
+import * as w from '../../../../warnings.js';
+import fuzzymatch from '../../../1-parse/utils/fuzzymatch.js';
+import { is_event_attribute, is_text_attribute } from '../../../../utils/ast.js';
+import { ContentEditableBindings } from '../../../constants.js';
 import { walk } from 'zimmerframe';
-import { list } from '../../utils/string.js';
+import { list } from '../../../../utils/string.js';
 
 const aria_roles = roles_map.keys();
 const abstract_roles = aria_roles.filter((role) => roles_map.get(role)?.abstract);
@@ -686,7 +686,7 @@ function get_static_text_value(attribute) {
  * @param {RegularElement | SvelteElement} node
  * @param {AnalysisState} state
  */
-function check_element(node, state) {
+export function check_element(node, state) {
 	// foreign namespace means elements can have completely different meanings, therefore we don't check them
 	if (state.options.namespace === 'foreign') return;
 
@@ -1154,15 +1154,3 @@ function check_element(node, state) {
 		w.a11y_missing_content(node, node.name);
 	}
 }
-
-/**
- * @type {Visitors<SvelteNode, AnalysisState>}
- */
-export const a11y_validators = {
-	RegularElement(node, context) {
-		check_element(node, context.state);
-	},
-	SvelteElement(node, context) {
-		check_element(node, context.state);
-	}
-};
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
new file mode 100644
index 0000000000..8f60a67c62
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js
@@ -0,0 +1,123 @@
+/** @import { Attribute, ElementLike } from '#compiler' */
+/** @import { Context } from '../../types' */
+import * as e from '../../../../errors.js';
+import { is_text_attribute } from '../../../../utils/ast.js';
+import * as w from '../../../../warnings.js';
+import { is_custom_element_node } from '../../../nodes.js';
+import { regex_only_whitespaces } from '../../../patterns.js';
+
+/**
+ * @param {Attribute} attribute
+ */
+export function validate_attribute_name(attribute) {
+	if (
+		attribute.name.includes(':') &&
+		!attribute.name.startsWith('xmlns:') &&
+		!attribute.name.startsWith('xlink:') &&
+		!attribute.name.startsWith('xml:')
+	) {
+		w.attribute_illegal_colon(attribute);
+	}
+}
+
+/**
+ * @param {Attribute} attribute
+ * @param {ElementLike} parent
+ */
+export function validate_attribute(attribute, parent) {
+	if (
+		Array.isArray(attribute.value) &&
+		attribute.value.length === 1 &&
+		attribute.value[0].type === 'ExpressionTag' &&
+		(parent.type === 'Component' ||
+			parent.type === 'SvelteComponent' ||
+			parent.type === 'SvelteSelf' ||
+			(parent.type === 'RegularElement' && is_custom_element_node(parent)))
+	) {
+		w.attribute_quoted(attribute);
+	}
+
+	if (attribute.value === true || !Array.isArray(attribute.value) || attribute.value.length === 1) {
+		return;
+	}
+
+	const is_quoted = attribute.value.at(-1)?.end !== attribute.end;
+
+	if (!is_quoted) {
+		e.attribute_unquoted_sequence(attribute);
+	}
+}
+
+/**
+ * @param {Context} context
+ * @param {Attribute} attribute
+ * @param {boolean} is_component
+ */
+export function validate_slot_attribute(context, attribute, is_component = false) {
+	const parent = context.path.at(-2);
+	let owner = undefined;
+
+	if (parent?.type === 'SnippetBlock') {
+		if (!is_text_attribute(attribute)) {
+			e.slot_attribute_invalid(attribute);
+		}
+		return;
+	}
+
+	let i = context.path.length;
+	while (i--) {
+		const ancestor = context.path[i];
+		if (
+			!owner &&
+			(ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteSelf' ||
+				ancestor.type === 'SvelteElement' ||
+				(ancestor.type === 'RegularElement' && is_custom_element_node(ancestor)))
+		) {
+			owner = ancestor;
+		}
+	}
+
+	if (owner) {
+		if (!is_text_attribute(attribute)) {
+			e.slot_attribute_invalid(attribute);
+		}
+
+		if (
+			owner.type === 'Component' ||
+			owner.type === 'SvelteComponent' ||
+			owner.type === 'SvelteSelf'
+		) {
+			if (owner !== parent) {
+				e.slot_attribute_invalid_placement(attribute);
+			}
+
+			const name = attribute.value[0].data;
+
+			if (context.state.component_slots.has(name)) {
+				e.slot_attribute_duplicate(attribute, name, owner.name);
+			}
+
+			context.state.component_slots.add(name);
+
+			if (name === 'default') {
+				for (const node of owner.fragment.nodes) {
+					if (node.type === 'Text' && regex_only_whitespaces.test(node.data)) {
+						continue;
+					}
+
+					if (node.type === 'RegularElement' || node.type === 'SvelteFragment') {
+						if (node.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')) {
+							continue;
+						}
+					}
+
+					e.slot_default_duplicate(node);
+				}
+			}
+		}
+	} else if (!is_component) {
+		e.slot_attribute_invalid_placement(attribute);
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/component.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/component.js
new file mode 100644
index 0000000000..347a59488a
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/component.js
@@ -0,0 +1,68 @@
+/** @import { Component, SvelteComponent, SvelteSelf } from '#compiler' */
+/** @import { Context } from '../../types' */
+import * as e from '../../../../errors.js';
+import { get_attribute_expression, is_expression_attribute } from '../../../../utils/ast.js';
+import {
+	validate_attribute,
+	validate_attribute_name,
+	validate_slot_attribute
+} from './attribute.js';
+
+/**
+ * @param {Component | SvelteComponent | SvelteSelf} node
+ * @param {Context} context
+ */
+export function visit_component(node, context) {
+	for (const attribute of node.attributes) {
+		if (
+			attribute.type !== 'Attribute' &&
+			attribute.type !== 'SpreadAttribute' &&
+			attribute.type !== 'LetDirective' &&
+			attribute.type !== 'OnDirective' &&
+			attribute.type !== 'BindDirective'
+		) {
+			e.component_invalid_directive(attribute);
+		}
+
+		if (
+			attribute.type === 'OnDirective' &&
+			(attribute.modifiers.length > 1 || attribute.modifiers.some((m) => m !== 'once'))
+		) {
+			e.event_handler_invalid_component_modifier(attribute);
+		}
+
+		if (attribute.type === 'Attribute') {
+			if (context.state.analysis.runes) {
+				validate_attribute(attribute, node);
+
+				if (is_expression_attribute(attribute)) {
+					const expression = get_attribute_expression(attribute);
+					if (expression.type === 'SequenceExpression') {
+						let i = /** @type {number} */ (expression.start);
+						while (--i > 0) {
+							const char = context.state.analysis.source[i];
+							if (char === '(') break; // parenthesized sequence expressions are ok
+							if (char === '{') e.attribute_invalid_sequence_expression(expression);
+						}
+					}
+				}
+			}
+
+			validate_attribute_name(attribute);
+
+			if (attribute.name === 'slot') {
+				validate_slot_attribute(context, attribute, true);
+			}
+		}
+
+		if (attribute.type === 'BindDirective' && attribute.name !== 'this') {
+			context.state.analysis.uses_component_bindings = true;
+		}
+	}
+
+	context.next({
+		...context.state,
+		parent_element: null,
+		component_slots: new Set()
+	});
+}
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
new file mode 100644
index 0000000000..2a2249080a
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
@@ -0,0 +1,149 @@
+/** @import { Component, RegularElement, SvelteComponent, SvelteElement, SvelteSelf, TransitionDirective } from '#compiler' */
+/** @import { Context } from '../../types' */
+import { get_attribute_expression, is_expression_attribute } from '../../../../utils/ast.js';
+import { regex_illegal_attribute_character } from '../../../patterns.js';
+import * as e from '../../../../errors.js';
+import * as w from '../../../../warnings.js';
+import { EventModifiers } from '../../../constants.js';
+import {
+	validate_attribute,
+	validate_attribute_name,
+	validate_slot_attribute
+} from './attribute.js';
+
+/**
+ * @param {import('#compiler').RegularElement | SvelteElement} node
+ * @param {Context} context
+ */
+export function validate_element(node, context) {
+	let has_animate_directive = false;
+
+	/** @type {TransitionDirective | null} */
+	let in_transition = null;
+
+	/** @type {TransitionDirective | null} */
+	let out_transition = null;
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			const is_expression = is_expression_attribute(attribute);
+
+			if (context.state.analysis.runes) {
+				validate_attribute(attribute, node);
+
+				if (is_expression) {
+					const expression = get_attribute_expression(attribute);
+					if (expression.type === 'SequenceExpression') {
+						let i = /** @type {number} */ (expression.start);
+						while (--i > 0) {
+							const char = context.state.analysis.source[i];
+							if (char === '(') break; // parenthesized sequence expressions are ok
+							if (char === '{') e.attribute_invalid_sequence_expression(expression);
+						}
+					}
+				}
+			}
+
+			if (regex_illegal_attribute_character.test(attribute.name)) {
+				e.attribute_invalid_name(attribute, attribute.name);
+			}
+
+			if (attribute.name.startsWith('on') && attribute.name.length > 2) {
+				if (!is_expression) {
+					e.attribute_invalid_event_handler(attribute);
+				}
+
+				const value = get_attribute_expression(attribute);
+				if (
+					value.type === 'Identifier' &&
+					value.name === attribute.name &&
+					!context.state.scope.get(value.name)
+				) {
+					w.attribute_global_event_reference(attribute, attribute.name);
+				}
+			}
+
+			if (attribute.name === 'slot') {
+				/** @type {RegularElement | SvelteElement | Component | SvelteComponent | SvelteSelf | undefined} */
+				validate_slot_attribute(context, attribute);
+			}
+
+			if (attribute.name === 'is' && context.state.options.namespace !== 'foreign') {
+				w.attribute_avoid_is(attribute);
+			}
+
+			const correct_name = react_attributes.get(attribute.name);
+			if (correct_name) {
+				w.attribute_invalid_property_name(attribute, attribute.name, correct_name);
+			}
+
+			validate_attribute_name(attribute);
+		} else if (attribute.type === 'AnimateDirective') {
+			const parent = context.path.at(-2);
+			if (parent?.type !== 'EachBlock') {
+				e.animation_invalid_placement(attribute);
+			} else if (!parent.key) {
+				e.animation_missing_key(attribute);
+			} else if (
+				parent.body.nodes.filter(
+					(n) =>
+						n.type !== 'Comment' &&
+						n.type !== 'ConstTag' &&
+						(n.type !== 'Text' || n.data.trim() !== '')
+				).length > 1
+			) {
+				e.animation_invalid_placement(attribute);
+			}
+
+			if (has_animate_directive) {
+				e.animation_duplicate(attribute);
+			} else {
+				has_animate_directive = true;
+			}
+		} else if (attribute.type === 'TransitionDirective') {
+			const existing = /** @type {TransitionDirective | null} */ (
+				(attribute.intro && in_transition) || (attribute.outro && out_transition)
+			);
+
+			if (existing) {
+				const a = existing.intro ? (existing.outro ? 'transition' : 'in') : 'out';
+				const b = attribute.intro ? (attribute.outro ? 'transition' : 'in') : 'out';
+
+				if (a === b) {
+					e.transition_duplicate(attribute, a);
+				} else {
+					e.transition_conflict(attribute, a, b);
+				}
+			}
+
+			if (attribute.intro) in_transition = attribute;
+			if (attribute.outro) out_transition = attribute;
+		} else if (attribute.type === 'OnDirective') {
+			let has_passive_modifier = false;
+			let conflicting_passive_modifier = '';
+			for (const modifier of attribute.modifiers) {
+				if (!EventModifiers.includes(modifier)) {
+					const list = `${EventModifiers.slice(0, -1).join(', ')} or ${EventModifiers.at(-1)}`;
+					e.event_handler_invalid_modifier(attribute, list);
+				}
+				if (modifier === 'passive') {
+					has_passive_modifier = true;
+				} else if (modifier === 'nonpassive' || modifier === 'preventDefault') {
+					conflicting_passive_modifier = modifier;
+				}
+				if (has_passive_modifier && conflicting_passive_modifier) {
+					e.event_handler_invalid_modifier_combination(
+						attribute,
+						'passive',
+						conflicting_passive_modifier
+					);
+				}
+			}
+		}
+	}
+}
+
+const react_attributes = new Map([
+	['className', 'class'],
+	['htmlFor', 'for']
+]);
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js
new file mode 100644
index 0000000000..da1f06d7f6
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js
@@ -0,0 +1,21 @@
+/** @import { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from 'estree' */
+/** @import { Context } from '../../types' */
+
+/**
+ * @param {ArrowFunctionExpression | FunctionExpression | FunctionDeclaration} node
+ * @param {Context} context
+ */
+export function visit_function(node, context) {
+	// TODO retire this in favour of a more general solution based on bindings
+	node.metadata = {
+		// module context -> already hoisted
+		hoistable: context.state.ast_type === 'module' ? 'impossible' : false,
+		hoistable_params: [],
+		scope: context.state.scope
+	};
+
+	context.next({
+		...context.state,
+		function_depth: context.state.function_depth + 1
+	});
+}
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
new file mode 100644
index 0000000000..dd790665ce
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
@@ -0,0 +1,167 @@
+/** @import { AssignmentExpression, Expression, Pattern, PrivateIdentifier, Super, UpdateExpression, VariableDeclarator } from 'estree' */
+/** @import { Fragment } from '#compiler' */
+/** @import { AnalysisState, Context } from '../../types' */
+/** @import { Scope } from '../../../scope' */
+/** @import { NodeLike } from '../../../../errors.js' */
+import * as e from '../../../../errors.js';
+import { extract_identifiers } from '../../../../utils/ast.js';
+import * as w from '../../../../warnings.js';
+
+/**
+ * @param {AssignmentExpression | UpdateExpression} node
+ * @param {Pattern | Expression} argument
+ * @param {AnalysisState} state
+ */
+export function validate_assignment(node, argument, state) {
+	validate_no_const_assignment(node, argument, state.scope, false);
+
+	if (argument.type === 'Identifier') {
+		const binding = state.scope.get(argument.name);
+
+		if (state.analysis.runes) {
+			if (binding?.kind === 'derived') {
+				e.constant_assignment(node, 'derived state');
+			}
+
+			if (binding?.kind === 'each') {
+				e.each_item_invalid_assignment(node);
+			}
+		}
+
+		if (binding?.kind === 'snippet') {
+			e.snippet_parameter_assignment(node);
+		}
+	}
+
+	let object = /** @type {Expression | Super} */ (argument);
+
+	/** @type {Expression | PrivateIdentifier | null} */
+	let property = null;
+
+	while (object.type === 'MemberExpression') {
+		property = object.property;
+		object = object.object;
+	}
+
+	if (object.type === 'ThisExpression' && property?.type === 'PrivateIdentifier') {
+		if (state.private_derived_state.includes(property.name)) {
+			e.constant_assignment(node, 'derived state');
+		}
+	}
+}
+
+/**
+ * @param {NodeLike} node
+ * @param {Pattern | Expression} argument
+ * @param {Scope} scope
+ * @param {boolean} is_binding
+ */
+export function validate_no_const_assignment(node, argument, scope, is_binding) {
+	if (argument.type === 'ArrayPattern') {
+		for (const element of argument.elements) {
+			if (element) {
+				validate_no_const_assignment(node, element, scope, is_binding);
+			}
+		}
+	} else if (argument.type === 'ObjectPattern') {
+		for (const element of argument.properties) {
+			if (element.type === 'Property') {
+				validate_no_const_assignment(node, element.value, scope, is_binding);
+			}
+		}
+	} else if (argument.type === 'Identifier') {
+		const binding = scope.get(argument.name);
+		if (binding?.declaration_kind === 'const' && binding.kind !== 'each') {
+			// e.invalid_const_assignment(
+			// 	node,
+			// 	is_binding,
+			// 	// This takes advantage of the fact that we don't assign initial for let directives and then/catch variables.
+			// 	// If we start doing that, we need another property on the binding to differentiate, or give up on the more precise error message.
+			// 	binding.kind !== 'state' &&
+			// 		binding.kind !== 'frozen_state' &&
+			// 		(binding.kind !== 'normal' || !binding.initial)
+			// );
+
+			// TODO have a more specific error message for assignments to things like `{:then foo}`
+			const thing = 'constant';
+
+			if (is_binding) {
+				e.constant_binding(node, thing);
+			} else {
+				e.constant_assignment(node, thing);
+			}
+		}
+	}
+}
+
+/**
+ * Validates that the opening of a control flow block is `{` immediately followed by the expected character.
+ * In legacy mode whitespace is allowed inbetween. TODO remove once legacy mode is gone and move this into parser instead.
+ * @param {{start: number; end: number}} node
+ * @param {AnalysisState} state
+ * @param {string} expected
+ */
+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);
+	}
+}
+
+/**
+ * @param {Fragment | null | undefined} node
+ * @param {Context} context
+ */
+export function validate_block_not_empty(node, context) {
+	if (!node) return;
+	// Assumption: If the block has zero elements, someone's in the middle of typing it out,
+	// so don't warn in that case because it would be distracting.
+	if (node.nodes.length === 1 && node.nodes[0].type === 'Text' && !node.nodes[0].raw.trim()) {
+		w.block_empty(node.nodes[0]);
+	}
+}
+
+/**
+ * @param {VariableDeclarator} node
+ * @param {AnalysisState} state
+ */
+export function ensure_no_module_import_conflict(node, state) {
+	const ids = extract_identifiers(node.id);
+	for (const id of ids) {
+		if (
+			state.ast_type === 'instance' &&
+			state.scope === state.analysis.instance.scope &&
+			state.analysis.module.scope.get(id.name)?.declaration_kind === 'import'
+		) {
+			// TODO fix the message here
+			e.declaration_duplicate_module_import(node.id);
+		}
+	}
+}
+
+/**
+ * A 'safe' identifier means that the `foo` in `foo.bar` or `foo()` will not
+ * call functions that require component context to exist
+ * @param {Expression | Super} expression
+ * @param {Scope} scope
+ */
+export function is_safe_identifier(expression, scope) {
+	let node = expression;
+	while (node.type === 'MemberExpression') node = node.object;
+
+	if (node.type !== 'Identifier') return false;
+
+	const binding = scope.get(node.name);
+	if (!binding) return true;
+
+	if (binding.kind === 'store_sub') {
+		return is_safe_identifier({ name: node.name.slice(1), type: 'Identifier' }, scope);
+	}
+
+	return (
+		binding.declaration_kind !== 'import' &&
+		binding.kind !== 'prop' &&
+		binding.kind !== 'bindable_prop' &&
+		binding.kind !== 'rest_prop'
+	);
+}
diff --git a/packages/svelte/src/compiler/phases/types.d.ts b/packages/svelte/src/compiler/phases/types.d.ts
index bd6cad135a..a223834d06 100644
--- a/packages/svelte/src/compiler/phases/types.d.ts
+++ b/packages/svelte/src/compiler/phases/types.d.ts
@@ -9,7 +9,7 @@ import type {
 	SvelteNode,
 	SvelteOptions
 } from '#compiler';
-import type { Identifier, LabeledStatement, Program, Statement, VariableDeclaration } from 'estree';
+import type { Identifier, LabeledStatement, Program, VariableDeclaration } from 'estree';
 import type { Scope, ScopeRoot } from './scope.js';
 
 export interface Js {
diff --git a/packages/svelte/src/compiler/phases/visitors.js b/packages/svelte/src/compiler/phases/visitors.js
index 35cf714eaf..5a52056ceb 100644
--- a/packages/svelte/src/compiler/phases/visitors.js
+++ b/packages/svelte/src/compiler/phases/visitors.js
@@ -8,6 +8,7 @@ const overrides = {
 	}
 };
 
+// TODO get rid of this
 /**
  * @template {{ type: string }} T
  * @template U
diff --git a/packages/svelte/src/compiler/utils/ast.js b/packages/svelte/src/compiler/utils/ast.js
index 7d786cb5fe..aef6c270a9 100644
--- a/packages/svelte/src/compiler/utils/ast.js
+++ b/packages/svelte/src/compiler/utils/ast.js
@@ -139,6 +139,7 @@ export function extract_identifiers(pattern) {
 
 /**
  * Extracts all identifiers and a stringified keypath from an expression.
+ * TODO replace this with `expression.dependencies`
  * @param {ESTree.Expression} expr
  * @returns {[keypath: string, ids: ESTree.Identifier[]]}
  */
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-instance/_config.js
similarity index 100%
rename from packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js
rename to packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-instance/_config.js
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/main.svelte b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-instance/main.svelte
similarity index 100%
rename from packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/main.svelte
rename to packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-instance/main.svelte
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-module/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-module/_config.js
new file mode 100644
index 0000000000..53ab3c7bcd
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-module/_config.js
@@ -0,0 +1,9 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'props_invalid_placement',
+		message:
+			'`$props()` can only be used at the top level of components as a variable declaration initializer'
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/main.svelte.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-module/main.svelte.js
similarity index 100%
rename from packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/main.svelte.js
rename to packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement-module/main.svelte.js