diff --git a/documentation/docs/98-reference/.generated/compile-errors.md b/documentation/docs/98-reference/.generated/compile-errors.md
index e8669ead533d..fb0591b884a5 100644
--- a/documentation/docs/98-reference/.generated/compile-errors.md
+++ b/documentation/docs/98-reference/.generated/compile-errors.md
@@ -208,6 +208,37 @@ Cannot assign to %thing%
 Cannot bind to %thing%
 ```
 
+### constructor_state_reassignment
+
+```
+Cannot redeclare stateful field `%name%` in the constructor. The field was originally declared here: `%original_location%`
+```
+
+To create stateful class fields in the constructor, the rune assignment must be the _first_ assignment to the class field.
+Assignments thereafter must not use the rune.
+
+```ts
+constructor() {
+	this.count = $state(0);
+	this.count = $state(1); // invalid, assigning to the same property with `$state` again
+}
+
+constructor() {
+	this.count = $state(0);
+	this.count = $state.raw(1); // invalid, assigning to the same property with a different rune
+}
+
+constructor() {
+	this.count = 0;
+	this.count = $state(1); // invalid, this property was created as a regular property, not state
+}
+
+constructor() {
+	this.count = $state(0);
+	this.count = 1; // valid, this is setting the state that has already been declared
+}
+```
+
 ### css_empty_declaration
 
 ```
@@ -855,7 +886,7 @@ Cannot export state from a module if it is reassigned. Either export a function
 ### state_invalid_placement
 
 ```
-`%rune%(...)` can only be used as a variable declaration initializer or a class field
+`%rune%(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.
 ```
 
 ### store_invalid_scoped_subscription
diff --git a/packages/svelte/messages/compile-errors/script.md b/packages/svelte/messages/compile-errors/script.md
index aabcbeae4812..780c9f4d2863 100644
--- a/packages/svelte/messages/compile-errors/script.md
+++ b/packages/svelte/messages/compile-errors/script.md
@@ -10,6 +10,35 @@
 
 > Cannot bind to %thing%
 
+## constructor_state_reassignment
+
+> Cannot redeclare stateful field `%name%` in the constructor. The field was originally declared here: `%original_location%`
+
+To create stateful class fields in the constructor, the rune assignment must be the _first_ assignment to the class field.
+Assignments thereafter must not use the rune.
+
+```ts
+constructor() {
+	this.count = $state(0);
+	this.count = $state(1); // invalid, assigning to the same property with `$state` again
+}
+
+constructor() {
+	this.count = $state(0);
+	this.count = $state.raw(1); // invalid, assigning to the same property with a different rune
+}
+
+constructor() {
+	this.count = 0;
+	this.count = $state(1); // invalid, this property was created as a regular property, not state
+}
+
+constructor() {
+	this.count = $state(0);
+	this.count = 1; // valid, this is setting the state that has already been declared
+}
+```
+
 ## declaration_duplicate
 
 > `%name%` has already been declared
@@ -218,7 +247,7 @@ It's possible to export a snippet from a `<script module>` block, but only if it
 
 ## state_invalid_placement
 
-> `%rune%(...)` can only be used as a variable declaration initializer or a class field
+> `%rune%(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.
 
 ## store_invalid_scoped_subscription
 
diff --git a/packages/svelte/src/compiler/errors.js b/packages/svelte/src/compiler/errors.js
index c99f59746863..fc814a16d31a 100644
--- a/packages/svelte/src/compiler/errors.js
+++ b/packages/svelte/src/compiler/errors.js
@@ -104,6 +104,17 @@ export function constant_binding(node, thing) {
 	e(node, 'constant_binding', `Cannot bind to ${thing}\nhttps://svelte.dev/e/constant_binding`);
 }
 
+/**
+ * Cannot redeclare stateful field `%name%` in the constructor. The field was originally declared here: `%original_location%`
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} original_location
+ * @returns {never}
+ */
+export function constructor_state_reassignment(node, name, original_location) {
+	e(node, 'constructor_state_reassignment', `Cannot redeclare stateful field \`${name}\` in the constructor. The field was originally declared here: \`${original_location}\`\nhttps://svelte.dev/e/constructor_state_reassignment`);
+}
+
 /**
  * `%name%` has already been declared
  * @param {null | number | NodeLike} node
@@ -471,13 +482,13 @@ export function state_invalid_export(node) {
 }
 
 /**
- * `%rune%(...)` can only be used as a variable declaration initializer or a class field
+ * `%rune%(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.
  * @param {null | number | NodeLike} node
  * @param {string} rune
  * @returns {never}
  */
 export function state_invalid_placement(node, rune) {
-	e(node, 'state_invalid_placement', `\`${rune}(...)\` can only be used as a variable declaration initializer or a class field\nhttps://svelte.dev/e/state_invalid_placement`);
+	e(node, 'state_invalid_placement', `\`${rune}(...)\` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.\nhttps://svelte.dev/e/state_invalid_placement`);
 }
 
 /**
diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index 2e36a896493f..ac9ab7689b41 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -22,7 +22,6 @@ 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';
@@ -46,6 +45,7 @@ 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 { PropertyDefinition } from './visitors/PropertyDefinition.js';
 import { RegularElement } from './visitors/RegularElement.js';
 import { RenderTag } from './visitors/RenderTag.js';
 import { SlotElement } from './visitors/SlotElement.js';
@@ -135,7 +135,6 @@ const visitors = {
 	AwaitBlock,
 	BindDirective,
 	CallExpression,
-	ClassBody,
 	ClassDeclaration,
 	ClassDirective,
 	Component,
@@ -159,6 +158,7 @@ const visitors = {
 	MemberExpression,
 	NewExpression,
 	OnDirective,
+	PropertyDefinition,
 	RegularElement,
 	RenderTag,
 	SlotElement,
@@ -259,7 +259,7 @@ export function analyze_module(ast, options) {
 			scope,
 			scopes,
 			analysis: /** @type {ComponentAnalysis} */ (analysis),
-			derived_state: [],
+			class_state: null,
 			// TODO the following are not needed for modules, but we have to pass them in order to avoid type error,
 			// and reducing the type would result in a lot of tedious type casts elsewhere - find a good solution one day
 			ast_type: /** @type {any} */ (null),
@@ -618,7 +618,7 @@ export function analyze_component(root, source, options) {
 				has_props_rune: false,
 				component_slots: new Set(),
 				expression: null,
-				derived_state: [],
+				class_state: null,
 				function_depth: scope.function_depth,
 				reactive_statement: null
 			};
@@ -685,7 +685,7 @@ export function analyze_component(root, source, options) {
 				reactive_statement: null,
 				component_slots: new Set(),
 				expression: null,
-				derived_state: [],
+				class_state: null,
 				function_depth: scope.function_depth
 			};
 
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 17c8123de1fe..5f9887e98980 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/types.d.ts
+++ b/packages/svelte/src/compiler/phases/2-analyze/types.d.ts
@@ -1,6 +1,7 @@
 import type { Scope } from '../scope.js';
 import type { ComponentAnalysis, ReactiveStatement } from '../types.js';
 import type { AST, ExpressionMetadata, ValidatedCompileOptions } from '#compiler';
+import type { ClassAnalysis } from './visitors/shared/class-analysis.js';
 
 export interface AnalysisState {
 	scope: Scope;
@@ -18,7 +19,9 @@ export interface AnalysisState {
 	component_slots: Set<string>;
 	/** Information about the current expression/directive/block value */
 	expression: ExpressionMetadata | null;
-	derived_state: { name: string; private: boolean }[];
+
+	/** Used to analyze class state. */
+	class_state: ClassAnalysis | null;
 	function_depth: number;
 
 	// legacy stuff
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
index a64c89cd88f1..9a94fc668ed9 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
@@ -23,5 +23,6 @@ export function AssignmentExpression(node, context) {
 		}
 	}
 
+	context.state.class_state?.register?.(node, context);
 	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
index 904817b014e4..2abf8a88b1d5 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
@@ -116,9 +116,14 @@ export function CallExpression(node, context) {
 		case '$derived':
 		case '$derived.by':
 			if (
-				(parent.type !== 'VariableDeclarator' ||
-					get_parent(context.path, -3).type === 'ConstTag') &&
-				!(parent.type === 'PropertyDefinition' && !parent.static && !parent.computed)
+				!(
+					call_expression_is_variable_declaration(parent, context) ||
+					call_expression_is_class_property_definition(parent) ||
+					context.state.class_state?.is_class_property_assignment_at_constructor_root(
+						parent,
+						context.path.slice(0, -1)
+					)
+				)
 			) {
 				e.state_invalid_placement(node, rune);
 			}
@@ -270,3 +275,20 @@ function get_function_label(nodes) {
 		return parent.id.name;
 	}
 }
+
+/**
+ *
+ * @param {AST.SvelteNode} parent
+ * @param {Context} context
+ */
+function call_expression_is_variable_declaration(parent, context) {
+	return parent.type === 'VariableDeclarator' && get_parent(context.path, -3).type !== 'ConstTag';
+}
+
+/**
+ *
+ * @param {AST.SvelteNode} parent
+ */
+function call_expression_is_class_property_definition(parent) {
+	return parent.type === 'PropertyDefinition' && !parent.static && !parent.computed;
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
deleted file mode 100644
index 0463e4da8563..000000000000
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
+++ /dev/null
@@ -1,30 +0,0 @@
-/** @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 {{name: string, private: boolean}[]} */
-	const derived_state = [];
-
-	for (const definition of node.body) {
-		if (
-			definition.type === 'PropertyDefinition' &&
-			(definition.key.type === 'PrivateIdentifier' || definition.key.type === 'Identifier') &&
-			definition.value?.type === 'CallExpression'
-		) {
-			const rune = get_rune(definition.value, context.state.scope);
-			if (rune === '$derived' || rune === '$derived.by') {
-				derived_state.push({
-					name: definition.key.name,
-					private: definition.key.type === 'PrivateIdentifier'
-				});
-			}
-		}
-	}
-
-	context.next({ ...context.state, 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
index 20925a65b737..b49ad099e59c 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDeclaration.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassDeclaration.js
@@ -1,6 +1,7 @@
 /** @import { ClassDeclaration } from 'estree' */
 /** @import { Context } from '../types' */
 import * as w from '../../../warnings.js';
+import { ClassAnalysis } from './shared/class-analysis.js';
 import { validate_identifier_name } from './shared/utils.js';
 
 /**
@@ -21,5 +22,8 @@ export function ClassDeclaration(node, context) {
 		w.perf_avoid_nested_class(node);
 	}
 
-	context.next();
+	context.next({
+		...context.state,
+		class_state: context.state.analysis.runes ? new ClassAnalysis() : null
+	});
 }
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/PropertyDefinition.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/PropertyDefinition.js
new file mode 100644
index 000000000000..6bf5eb73d5db
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/PropertyDefinition.js
@@ -0,0 +1,12 @@
+/** @import { PropertyDefinition } from 'estree' */
+/** @import { Context } from '../types' */
+
+/**
+ *
+ * @param {PropertyDefinition} node
+ * @param {Context} context
+ */
+export function PropertyDefinition(node, context) {
+	context.state.class_state?.register?.(node, context);
+	context.next();
+}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/class-analysis.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/class-analysis.js
new file mode 100644
index 000000000000..4b3d758200b6
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/class-analysis.js
@@ -0,0 +1,142 @@
+/** @import { AssignmentExpression, PropertyDefinition, Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../../types' */
+/** @import { StateCreationRuneName } from '../../../../../utils.js' */
+
+import { get_parent } from '../../../../utils/ast.js';
+import { get_rune } from '../../../scope.js';
+import * as e from '../../../../errors.js';
+import { locate_node } from '../../../../state.js';
+import { is_state_creation_rune } from '../../../../../utils.js';
+
+/** @typedef { StateCreationRuneName | 'regular'} PropertyAssignmentType */
+/** @typedef {{ type: PropertyAssignmentType; node: AssignmentExpression | PropertyDefinition; }} PropertyAssignmentDetails */
+
+const reassignable_assignments = new Set(['$state', '$state.raw', 'regular']);
+
+export class ClassAnalysis {
+	// TODO: Probably need to include property definitions here too
+	/** @type {Map<string, PropertyAssignmentDetails>} */
+	property_assignments = new Map();
+
+	/**
+	 * Determines if the node is a valid assignment to a class property, and if so,
+	 * registers the assignment.
+	 * @param {AssignmentExpression | PropertyDefinition} node
+	 * @param {Context} context
+	 */
+	register(node, context) {
+		/** @type {string} */
+		let name;
+		/** @type {PropertyAssignmentType} */
+		let type;
+
+		if (node.type === 'AssignmentExpression') {
+			if (!this.is_class_property_assignment_at_constructor_root(node, context.path)) {
+				return;
+			}
+			name = node.left.property.name;
+			type = this.#get_assignment_type(node, context);
+
+			this.#check_for_conflicts(node, name, type);
+		} else {
+			if (!this.#is_assigned_property(node)) {
+				return;
+			}
+
+			name = node.key.name;
+			type = this.#get_assignment_type(node, context);
+
+			// we don't need to check for conflicts here because they're not possible yet
+		}
+
+		// we don't have to validate anything other than conflicts here, because the rune placement rules
+		// catch all of the other weirdness.
+		if (!this.property_assignments.has(name)) {
+			this.property_assignments.set(name, { type, node });
+		}
+	}
+
+	/**
+	 * @template {AST.SvelteNode} T
+	 * @param {AST.SvelteNode} node
+	 * @param {T[]} path
+	 * @returns {node is AssignmentExpression & { left: { type: 'MemberExpression' } & { object: { type: 'ThisExpression' }; property: { type: 'Identifier' | 'PrivateIdentifier' } } }}
+	 */
+	is_class_property_assignment_at_constructor_root(node, path) {
+		if (
+			!(
+				node.type === 'AssignmentExpression' &&
+				node.operator === '=' &&
+				node.left.type === 'MemberExpression' &&
+				node.left.object.type === 'ThisExpression' &&
+				(node.left.property.type === 'Identifier' ||
+					node.left.property.type === 'PrivateIdentifier')
+			)
+		) {
+			return false;
+		}
+		// AssignmentExpression (here) -> ExpressionStatement (-1) -> BlockStatement (-2) -> FunctionExpression (-3) -> MethodDefinition (-4)
+		const maybe_constructor = get_parent(path, -4);
+		return (
+			maybe_constructor &&
+			maybe_constructor.type === 'MethodDefinition' &&
+			maybe_constructor.kind === 'constructor'
+		);
+	}
+
+	/**
+	 * We only care about properties that have values assigned to them -- if they don't,
+	 * they can't be a conflict for state declared in the constructor.
+	 * @param {PropertyDefinition} node
+	 * @returns {node is PropertyDefinition & { key: { type: 'PrivateIdentifier' | 'Identifier' }; value: Expression; static: false; computed: false }}
+	 */
+	#is_assigned_property(node) {
+		return (
+			(node.key.type === 'PrivateIdentifier' || node.key.type === 'Identifier') &&
+			Boolean(node.value) &&
+			!node.static &&
+			!node.computed
+		);
+	}
+
+	/**
+	 * Checks for conflicts with existing assignments. A conflict occurs if:
+	 * - The original assignment used `$derived` or `$derived.by` (these can never be reassigned)
+	 * - The original assignment used `$state`, `$state.raw`, or `regular` and is being assigned to with any type other than `regular`
+	 * @param {AssignmentExpression} node
+	 * @param {string} name
+	 * @param {PropertyAssignmentType} type
+	 */
+	#check_for_conflicts(node, name, type) {
+		const existing = this.property_assignments.get(name);
+		if (!existing) {
+			return;
+		}
+
+		if (reassignable_assignments.has(existing.type) && type === 'regular') {
+			return;
+		}
+
+		e.constructor_state_reassignment(node, name, locate_node(existing.node));
+	}
+
+	/**
+	 * @param {AssignmentExpression | PropertyDefinition} node
+	 * @param {Context} context
+	 * @returns {PropertyAssignmentType}
+	 */
+	#get_assignment_type(node, context) {
+		const value = node.type === 'AssignmentExpression' ? node.right : node.value;
+		const rune = get_rune(value, context.state.scope);
+		if (rune === null) {
+			return 'regular';
+		}
+		if (is_state_creation_rune(rune)) {
+			return rune;
+		}
+		// this does mean we return `regular` for some other runes (like `$trace` or `$state.raw`)
+		// -- this is ok because the rune placement rules will throw if they're invalid.
+		return 'regular';
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
index f0da5a491887..ff448f31a126 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
@@ -161,8 +161,7 @@ export function client_component(analysis, options) {
 		},
 		events: new Set(),
 		preserve_whitespace: options.preserveWhitespace,
-		public_state: new Map(),
-		private_state: new Map(),
+		class_analysis: null,
 		transform: {},
 		in_constructor: false,
 		instance_level_snippets: [],
@@ -669,10 +668,9 @@ export function client_module(analysis, options) {
 		options,
 		scope: analysis.module.scope,
 		scopes: analysis.module.scopes,
-		public_state: new Map(),
-		private_state: new Map(),
 		transform: {},
-		in_constructor: false
+		in_constructor: false,
+		class_analysis: null
 	};
 
 	const module = /** @type {ESTree.Program} */ (
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/types.d.ts b/packages/svelte/src/compiler/phases/3-transform/client/types.d.ts
index 243e1c64a33c..2ab5bd1a6094 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/types.d.ts
+++ b/packages/svelte/src/compiler/phases/3-transform/client/types.d.ts
@@ -13,10 +13,11 @@ import type { AST, Namespace, ValidatedCompileOptions } from '#compiler';
 import type { TransformState } from '../types.js';
 import type { ComponentAnalysis } from '../../types.js';
 import type { SourceLocation } from '#shared';
+import type { StateCreationRuneName } from '../../../../utils.js';
+import type { ClassAnalysis } from './visitors/shared/class-analysis.js';
 
 export interface ClientTransformState extends TransformState {
-	readonly private_state: Map<string, StateField>;
-	readonly public_state: Map<string, StateField>;
+	readonly class_analysis: ClassAnalysis | null;
 
 	/**
 	 * `true` if the current lexical scope belongs to a class constructor. this allows
@@ -95,7 +96,7 @@ export interface ComponentClientTransformState extends ClientTransformState {
 }
 
 export interface StateField {
-	kind: 'state' | 'raw_state' | 'derived' | 'derived_by';
+	kind: StateCreationRuneName;
 	id: PrivateIdentifier;
 }
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
index e3f945005051..d045b83298f3 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
@@ -1,4 +1,4 @@
-/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, Pattern } from 'estree' */
+/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, Pattern, MemberExpression, ThisExpression, PrivateIdentifier, CallExpression } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { Context } from '../types.js' */
 import * as b from '#compiler/builders';
@@ -17,6 +17,7 @@ import { validate_mutation } from './shared/utils.js';
  * @param {Context} context
  */
 export function AssignmentExpression(node, context) {
+	context.state.class_analysis?.register_assignment(node, context);
 	const expression = /** @type {Expression} */ (
 		visit_assignment_expression(node, context, build_assignment) ?? context.next()
 	);
@@ -56,7 +57,7 @@ function build_assignment(operator, left, right, context) {
 		left.type === 'MemberExpression' &&
 		left.property.type === 'PrivateIdentifier'
 	) {
-		const private_state = context.state.private_state.get(left.property.name);
+		const private_state = context.state.class_analysis?.private_state.get(left.property.name);
 
 		if (private_state !== undefined) {
 			let value = /** @type {Expression} */ (
@@ -64,7 +65,7 @@ function build_assignment(operator, left, right, context) {
 			);
 
 			const needs_proxy =
-				private_state.kind === 'state' &&
+				private_state.kind === '$state' &&
 				is_non_coercive_operator(operator) &&
 				should_proxy(value, context.state.scope);
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ClassBody.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/ClassBody.js
index f3ebd940699c..534fdba44672 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ClassBody.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/ClassBody.js
@@ -1,9 +1,7 @@
-/** @import { ClassBody, Expression, Identifier, Literal, MethodDefinition, PrivateIdentifier, PropertyDefinition } from 'estree' */
+/** @import { ClassBody, Identifier, Literal, MethodDefinition, PrivateIdentifier, PropertyDefinition } from 'estree' */
 /** @import { Context, StateField } from '../types' */
-import * as b from '#compiler/builders';
 import { regex_invalid_identifier_chars } from '../../../patterns.js';
-import { get_rune } from '../../../scope.js';
-import { should_proxy } from '../utils.js';
+import { ClassAnalysis } from './shared/class-analysis.js';
 
 /**
  * @param {ClassBody} node
@@ -15,170 +13,46 @@ export function ClassBody(node, context) {
 		return;
 	}
 
-	/** @type {Map<string, StateField>} */
-	const public_state = new Map();
-
-	/** @type {Map<string, StateField>} */
-	const private_state = new Map();
-
-	/** @type {Map<(MethodDefinition|PropertyDefinition)["key"], string>} */
-	const definition_names = new Map();
-
-	/** @type {string[]} */
-	const private_ids = [];
+	const class_analysis = new ClassAnalysis();
 
 	for (const definition of node.body) {
-		if (
-			(definition.type === 'PropertyDefinition' || definition.type === 'MethodDefinition') &&
-			(definition.key.type === 'Identifier' ||
-				definition.key.type === 'PrivateIdentifier' ||
-				definition.key.type === 'Literal')
-		) {
-			const type = definition.key.type;
-			const name = get_name(definition.key, public_state);
-			if (!name) continue;
-
-			// we store the deconflicted name in the map so that we can access it later
-			definition_names.set(definition.key, name);
-
-			const is_private = type === 'PrivateIdentifier';
-			if (is_private) private_ids.push(name);
-
-			if (definition.value?.type === 'CallExpression') {
-				const rune = get_rune(definition.value, context.state.scope);
-				if (
-					rune === '$state' ||
-					rune === '$state.raw' ||
-					rune === '$derived' ||
-					rune === '$derived.by'
-				) {
-					/** @type {StateField} */
-					const field = {
-						kind:
-							rune === '$state'
-								? 'state'
-								: rune === '$state.raw'
-									? 'raw_state'
-									: rune === '$derived.by'
-										? 'derived_by'
-										: 'derived',
-						// @ts-expect-error this is set in the next pass
-						id: is_private ? definition.key : null
-					};
-
-					if (is_private) {
-						private_state.set(name, field);
-					} else {
-						public_state.set(name, field);
-					}
-				}
-			}
-		}
+		class_analysis.register_body_definition(definition, context.state.scope);
 	}
 
-	// each `foo = $state()` needs a backing `#foo` field
-	for (const [name, field] of public_state) {
-		let deconflicted = name;
-		while (private_ids.includes(deconflicted)) {
-			deconflicted = '_' + deconflicted;
-		}
-
-		private_ids.push(deconflicted);
-		field.id = b.private_id(deconflicted);
-	}
+	class_analysis.finalize_property_definitions();
 
 	/** @type {Array<MethodDefinition | PropertyDefinition>} */
 	const body = [];
 
-	const child_state = { ...context.state, public_state, private_state };
+	const child_state = {
+		...context.state,
+		class_analysis
+	};
+
+	// we need to visit the constructor first so that it can add to the field maps.
+	const constructor_node = node.body.find(
+		(child) => child.type === 'MethodDefinition' && child.kind === 'constructor'
+	);
+	const constructor = constructor_node && context.visit(constructor_node, child_state);
 
 	// Replace parts of the class body
 	for (const definition of node.body) {
-		if (
-			definition.type === 'PropertyDefinition' &&
-			(definition.key.type === 'Identifier' ||
-				definition.key.type === 'PrivateIdentifier' ||
-				definition.key.type === 'Literal')
-		) {
-			const name = definition_names.get(definition.key);
-			if (!name) continue;
-
-			const is_private = definition.key.type === 'PrivateIdentifier';
-			const field = (is_private ? private_state : public_state).get(name);
-
-			if (definition.value?.type === 'CallExpression' && field !== undefined) {
-				let value = null;
-
-				if (definition.value.arguments.length > 0) {
-					const init = /** @type {Expression} **/ (
-						context.visit(definition.value.arguments[0], child_state)
-					);
-
-					value =
-						field.kind === 'state'
-							? b.call(
-									'$.state',
-									should_proxy(init, context.state.scope) ? b.call('$.proxy', init) : init
-								)
-							: field.kind === 'raw_state'
-								? b.call('$.state', init)
-								: field.kind === 'derived_by'
-									? b.call('$.derived', init)
-									: b.call('$.derived', b.thunk(init));
-				} else {
-					// if no arguments, we know it's state as `$derived()` is a compile error
-					value = b.call('$.state');
-				}
-
-				if (is_private) {
-					body.push(b.prop_def(field.id, value));
-				} else {
-					// #foo;
-					const member = b.member(b.this, field.id);
-					body.push(b.prop_def(field.id, value));
-
-					// get foo() { return this.#foo; }
-					body.push(b.method('get', definition.key, [], [b.return(b.call('$.get', member))]));
+		if (definition === constructor_node) {
+			body.push(/** @type {MethodDefinition} */ (constructor));
+			continue;
+		}
 
-					// set foo(value) { this.#foo = value; }
-					const val = b.id('value');
+		const state_field = class_analysis.build_state_field_from_body_definition(definition, context);
 
-					body.push(
-						b.method(
-							'set',
-							definition.key,
-							[val],
-							[b.stmt(b.call('$.set', member, val, field.kind === 'state' && b.true))]
-						)
-					);
-				}
-				continue;
-			}
+		if (state_field) {
+			body.push(...state_field);
+			continue;
 		}
 
 		body.push(/** @type {MethodDefinition} **/ (context.visit(definition, child_state)));
 	}
 
-	return { ...node, body };
-}
+	body.push(...class_analysis.constructor_state_fields);
 
-/**
- * @param {Identifier | PrivateIdentifier | Literal} node
- * @param {Map<string, StateField>} public_state
- */
-function get_name(node, public_state) {
-	if (node.type === 'Literal') {
-		let name = node.value?.toString().replace(regex_invalid_identifier_chars, '_');
-
-		// the above could generate conflicts because it has to generate a valid identifier
-		// so stuff like `0` and `1` or `state%` and `state^` will result in the same string
-		// so we have to de-conflict. We can only check `public_state` because private state
-		// can't have literal keys
-		while (name && public_state.has(name)) {
-			name = '_' + name;
-		}
-		return name;
-	} else {
-		return node.name;
-	}
+	return { ...node, body };
 }
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/MemberExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/MemberExpression.js
index ab88345ddd3c..410c9ad9ab79 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/MemberExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/MemberExpression.js
@@ -9,9 +9,10 @@ import * as b from '#compiler/builders';
 export function MemberExpression(node, context) {
 	// rewrite `this.#foo` as `this.#foo.v` inside a constructor
 	if (node.property.type === 'PrivateIdentifier') {
-		const field = context.state.private_state.get(node.property.name);
+		const field = context.state.class_analysis?.private_state.get(node.property.name);
 		if (field) {
-			return context.state.in_constructor && (field.kind === 'raw_state' || field.kind === 'state')
+			return context.state.in_constructor &&
+				(field.kind === '$state.raw' || field.kind === '$state')
 				? b.member(node, 'v')
 				: b.call('$.get', node);
 		}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
index 96be119b840a..c1f7c390ced9 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
@@ -15,7 +15,7 @@ export function UpdateExpression(node, context) {
 		argument.type === 'MemberExpression' &&
 		argument.object.type === 'ThisExpression' &&
 		argument.property.type === 'PrivateIdentifier' &&
-		context.state.private_state.has(argument.property.name)
+		context.state.class_analysis?.private_state.has(argument.property.name)
 	) {
 		let fn = '$.update';
 		if (node.prefix) fn += '_pre';
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/class-analysis.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/class-analysis.js
new file mode 100644
index 000000000000..0ce4451e8ba2
--- /dev/null
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/class-analysis.js
@@ -0,0 +1,301 @@
+/** @import { Context, StateField } from '../../types.js' */
+/** @import { AssignmentExpression, Identifier, Literal, MethodDefinition, PrivateIdentifier, PropertyDefinition, CallExpression, Expression, StaticBlock, SpreadElement } from 'estree' */
+/** @import { Scope } from '#compiler' */
+/** @import { StateCreationRuneName } from '../../../../../../utils.js' */
+import * as b from '#compiler/builders';
+import { is_state_creation_rune } from '../../../../../../utils.js';
+import { regex_invalid_identifier_chars } from '../../../../patterns.js';
+import { get_rune } from '../../../../scope.js';
+import { should_proxy } from '../../utils.js';
+
+export class ClassAnalysis {
+	/** @type {Map<string, StateField>} */
+	public_state = new Map();
+
+	/** @type {Map<string, StateField>} */
+	private_state = new Map();
+
+	/**
+	 * Any state fields discovered from {@link register_assignment} that need to be added to the class body.
+	 * @type {Array<PropertyDefinition | MethodDefinition>}
+	 */
+	constructor_state_fields = [];
+
+	/** @type {Map<(MethodDefinition | PropertyDefinition)["key"], string>} */
+	#definition_names = new Map();
+
+	/** @type {Set<string>} */
+	#private_ids = new Set();
+
+	/**
+	 * @param {MethodDefinition | PropertyDefinition | StaticBlock} node
+	 * @param {Scope} scope
+	 */
+	register_body_definition(node, scope) {
+		if (
+			!(
+				(node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') &&
+				(node.key.type === 'Identifier' ||
+					node.key.type === 'PrivateIdentifier' ||
+					node.key.type === 'Literal')
+			)
+		) {
+			return;
+		}
+
+		/*
+		 * We don't know if the node is stateful yet, but we still need to register some details.
+		 * For example: If the node is a private identifier, we could accidentally conflict with it later
+		 * if we create a private field for public state (as would happen in this example:)
+		 *
+		 * ```ts
+		 * class Foo {
+		 *   #count = 0;
+		 *   count = $state(0); // would become #count if we didn't know about the private field above
+		 * }
+		 */
+
+		const name = ClassAnalysis.#get_name(node.key, this.public_state);
+		if (!name) {
+			return;
+		}
+
+		// we store the deconflicted name in the map so that we can access it later
+		this.#definition_names.set(node.key, name);
+
+		const is_private = node.key.type === 'PrivateIdentifier';
+		if (is_private) {
+			this.#private_ids.add(name);
+		}
+
+		const rune = get_rune(node.value, scope);
+		if (!rune || !is_state_creation_rune(rune)) {
+			return;
+		}
+
+		if (is_private) {
+			this.private_state.set(name, { kind: rune, id: /** @type {PrivateIdentifier} */ (node.key) });
+		} else {
+			// We can't set the ID until we've identified all of the private state fields,
+			// otherwise we might conflict with them. After registering all property definitions,
+			// call `finalize_property_definitions` to populate the IDs.
+			// @ts-expect-error this is set in `finalize_property_definitions`
+			this.public_state.set(name, { kind: rune, id: undefined });
+		}
+	}
+
+	/**
+	 * Resolves all of the registered public state fields to their final private IDs.
+	 * Must be called after all property definitions have been registered.
+	 */
+	finalize_property_definitions() {
+		for (const [name, field] of this.public_state) {
+			field.id = this.#deconflict(name);
+		}
+	}
+
+	/**
+	 * Important note: It is a syntax error in JavaScript to try to assign to a private class field
+	 * that was not declared in the class body. So there is absolutely no risk of unresolvable conflicts here.
+	 *
+	 * This function will modify the assignment expression passed to it if it is registered as a state field.
+	 * @param {AssignmentExpression} node
+	 * @param {Context} context
+	 */
+	register_assignment(node, context) {
+		if (
+			!(
+				node.operator === '=' &&
+				node.left.type === 'MemberExpression' &&
+				node.left.object.type === 'ThisExpression' &&
+				node.left.property.type === 'Identifier'
+			)
+		) {
+			return;
+		}
+
+		const name = ClassAnalysis.#get_name(node.left.property, this.public_state);
+		if (!name) {
+			return;
+		}
+
+		const rune = get_rune(node.right, context.state.scope);
+		if (!rune || !is_state_creation_rune(rune)) {
+			return;
+		}
+
+		const id = this.#deconflict(name);
+		const field = { kind: rune, id };
+		this.public_state.set(name, field);
+
+		// We need to do two things:
+		// - Communicate to the class body visitor that it needs to append nodes to create a state field
+		// - Modify the assignment expression so that it's valid
+		this.constructor_state_fields.push(
+			...this.build_state_field(
+				false,
+				field,
+				node.left.property,
+				// this will initialize the field without assigning to it, delegating to the constructor
+				null,
+				context
+			)
+		);
+
+		// ...swap out the assignment to go directly against the private field
+		node.left.property = id;
+		// ...and swap out the assignment's value for the state field init
+		node.right = this.#build_init_value(
+			rune,
+			/** @type {CallExpression} */ (node.right).arguments[0],
+			context
+		);
+	}
+
+	/**
+	 *
+	 * @param {PropertyDefinition | MethodDefinition | StaticBlock} node
+	 * @param {Context} context
+	 * @returns {Array<PropertyDefinition | MethodDefinition> | null}
+	 */
+	build_state_field_from_body_definition(node, context) {
+		if (
+			!(
+				node.type === 'PropertyDefinition' &&
+				(node.key.type === 'Identifier' ||
+					node.key.type === 'PrivateIdentifier' ||
+					node.key.type === 'Literal')
+			)
+		) {
+			return null;
+		}
+
+		const name = this.#definition_names.get(node.key);
+		if (!name) throw new Error('This should not be possible'); // TODO
+
+		const is_private = node.key.type === 'PrivateIdentifier';
+		const field = (is_private ? this.private_state : this.public_state).get(name);
+
+		if (!field) {
+			return null;
+		}
+
+		return this.build_state_field(
+			is_private,
+			field,
+			node.key,
+			// we can cast this because if we have a field for this definition it definitely is a call
+			// expression, otherwise it wouldn't have produced a rune earlier.
+			/** @type {CallExpression} */ (node.value),
+			context
+		);
+	}
+
+	/**
+	 * @param {boolean} is_private
+	 * @param {StateField} field
+	 * @param {(MethodDefinition | PropertyDefinition)["key"]} original_definition_id
+	 * @param {CallExpression | null} call_expression
+	 * @param {Context} context
+	 *
+	 * @returns {Array<PropertyDefinition | MethodDefinition>}
+	 */
+	build_state_field(is_private, field, original_definition_id, call_expression, context) {
+		let value;
+		if (!call_expression) {
+			// if there's no call expression, this is state that's created in the constructor.
+			// it's guaranteed to be the very first assignment to this field, so we initialize
+			// the field but don't assign to it.
+			value = null;
+		} else if (call_expression.arguments.length > 0) {
+			value = this.#build_init_value(field.kind, call_expression.arguments[0], context);
+		} else {
+			// if no arguments, we know it's state as `$derived()` is a compile error
+			value = b.call('$.state');
+		}
+
+		if (is_private) {
+			return [b.prop_def(field.id, value)];
+		}
+
+		const member = b.member(b.this, field.id);
+		const val = b.id('value');
+		return [
+			// #foo;
+			b.prop_def(field.id, value),
+			// get foo() { return this.#foo; }
+			b.method('get', original_definition_id, [], [b.return(b.call('$.get', member))]),
+			// set foo(value) { this.#foo = value; }
+			b.method(
+				'set',
+				original_definition_id,
+				[val],
+				[b.stmt(b.call('$.set', member, val, field.kind === '$state' && b.true))]
+			)
+		];
+	}
+
+	/**
+	 *
+	 * @param {StateCreationRuneName} kind
+	 * @param {Expression | SpreadElement} arg
+	 * @param {Context} context
+	 */
+	#build_init_value(kind, arg, context) {
+		const init = /** @type {Expression} **/ (
+			context.visit(arg, {
+				...context.state,
+				class_analysis: this
+			})
+		);
+
+		switch (kind) {
+			case '$state':
+				return b.call(
+					'$.state',
+					should_proxy(init, context.state.scope) ? b.call('$.proxy', init) : init
+				);
+			case '$state.raw':
+				return b.call('$.state', init);
+			case '$derived':
+				return b.call('$.derived', b.thunk(init));
+			case '$derived.by':
+				return b.call('$.derived', init);
+		}
+	}
+
+	/**
+	 * @param {string} name
+	 * @returns {PrivateIdentifier}
+	 */
+	#deconflict(name) {
+		let deconflicted = name;
+		while (this.#private_ids.has(deconflicted)) {
+			deconflicted = '_' + deconflicted;
+		}
+
+		this.#private_ids.add(deconflicted);
+		return b.private_id(deconflicted);
+	}
+
+	/**
+	 * @param {Identifier | PrivateIdentifier | Literal} node
+	 * @param {Map<string, unknown>} public_state
+	 */
+	static #get_name(node, public_state) {
+		if (node.type === 'Literal') {
+			let name = node.value?.toString().replace(regex_invalid_identifier_chars, '_');
+
+			// the above could generate conflicts because it has to generate a valid identifier
+			// so stuff like `0` and `1` or `state%` and `state^` will result in the same string
+			// so we have to de-conflict. We can only check `public_state` because private state
+			// can't have literal keys
+			while (name && public_state.has(name)) {
+				name = '_' + name;
+			}
+			return name;
+		} else {
+			return node.name;
+		}
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/ClassBody.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/ClassBody.js
index c0ebdeae0822..ff4a1206ddaa 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/ClassBody.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/ClassBody.js
@@ -39,7 +39,7 @@ export function ClassBody(node, context) {
 				if (rune === '$derived' || rune === '$derived.by') {
 					/** @type {StateField} */
 					const field = {
-						kind: rune === '$derived.by' ? 'derived_by' : 'derived',
+						kind: rune,
 						// @ts-expect-error this is set in the next pass
 						id: is_private ? definition.key : null
 					};
@@ -86,7 +86,7 @@ export function ClassBody(node, context) {
 					context.visit(definition.value.arguments[0], child_state)
 				);
 				const value =
-					field.kind === 'derived_by' ? b.call('$.once', init) : b.call('$.once', b.thunk(init));
+					field.kind === '$derived.by' ? b.call('$.once', init) : b.call('$.once', b.thunk(init));
 
 				if (is_private) {
 					body.push(b.prop_def(field.id, value));
@@ -98,7 +98,7 @@ export function ClassBody(node, context) {
 					// get foo() { return this.#foo; }
 					body.push(b.method('get', definition.key, [], [b.return(b.call(member))]));
 
-					if (dev && (field.kind === 'derived' || field.kind === 'derived_by')) {
+					if (dev && (field.kind === '$derived' || field.kind === '$derived.by')) {
 						body.push(
 							b.method(
 								'set',
diff --git a/packages/svelte/src/utils.js b/packages/svelte/src/utils.js
index ada318e85ac7..2758b9fcbc19 100644
--- a/packages/svelte/src/utils.js
+++ b/packages/svelte/src/utils.js
@@ -447,14 +447,28 @@ const RUNES = /** @type {const} */ ([
 	'$host'
 ]);
 
+/** @typedef {RUNES[number]} RuneName */
+
 /**
  * @param {string} name
- * @returns {name is RUNES[number]}
+ * @returns {name is RuneName}
  */
 export function is_rune(name) {
 	return RUNES.includes(/** @type {RUNES[number]} */ (name));
 }
 
+/** @typedef {'$state' | '$state.raw' | '$derived' | '$derived.by'} StateCreationRuneName */
+
+/**
+ * @param {string} name
+ * @returns {name is StateCreationRuneName}
+ */
+export function is_state_creation_rune(name) {
+	return (
+		name === '$state' || name === '$state.raw' || name === '$derived' || name === '$derived.by'
+	);
+}
+
 /** List of elements that require raw contents and should not have SSR comments put in them */
 const RAW_TEXT_ELEMENTS = /** @type {const} */ (['textarea', 'script', 'style', 'title']);
 
diff --git a/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js b/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
index e6551031cc8e..f5b116117ed3 100644
--- a/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
@@ -4,7 +4,7 @@ export default test({
 	error: {
 		code: 'state_invalid_placement',
 		message:
-			'`$state(...)` can only be used as a variable declaration initializer or a class field',
+			'`$state(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.',
 		position: [33, 41]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
index 1185ca6b4548..592b2634a389 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
@@ -3,6 +3,7 @@ import { test } from '../../test';
 export default test({
 	error: {
 		code: 'state_invalid_placement',
-		message: '`$state(...)` can only be used as a variable declaration initializer or a class field'
+		message:
+			'`$state(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
index 476d7239a307..f31748d26a40 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
@@ -4,6 +4,6 @@ export default test({
 	error: {
 		code: 'state_invalid_placement',
 		message:
-			'`$derived(...)` can only be used as a variable declaration initializer or a class field'
+			'`$derived(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
index 1185ca6b4548..592b2634a389 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
@@ -3,6 +3,7 @@ import { test } from '../../test';
 export default test({
 	error: {
 		code: 'state_invalid_placement',
-		message: '`$state(...)` can only be used as a variable declaration initializer or a class field'
+		message:
+			'`$state(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.'
 	}
 });
diff --git a/packages/svelte/tests/validator/samples/const-tag-invalid-rune-usage/errors.json b/packages/svelte/tests/validator/samples/const-tag-invalid-rune-usage/errors.json
index 32594e426846..e1906b181a4d 100644
--- a/packages/svelte/tests/validator/samples/const-tag-invalid-rune-usage/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-invalid-rune-usage/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"code": "state_invalid_placement",
-		"message": "`$derived(...)` can only be used as a variable declaration initializer or a class field",
+		"message": "`$derived(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.",
 		"start": {
 			"line": 2,
 			"column": 15