From 5cfa5495a07b5dec9c874ad9cedf0ed21882c51c Mon Sep 17 00:00:00 2001
From: Socialpranker <273312799+Socialpranker@users.noreply.github.com>
Date: Mon, 27 Jul 2026 21:31:12 +0200
Subject: [PATCH 1/3] feat: support `defaultValue` on `<select>`

`<select>` had no way to express a default selection other than putting
`selected` on the matching `<option>`, which is awkward when the options
are generated and impossible when the element is spread from an object.

`defaultValue` was silently ignored: `is_dom_property()` treats it as a
property, so the client compiled it to `select.defaultValue = value`,
which does nothing on `HTMLSelectElement`, and the server dropped it.

Client-side it now marks the matching option as `selected`, which is the
state the form reset algorithm restores. The call is emitted after the
children so the options exist and have had their values assigned. The
current selection is only preserved when something asked for a specific
option, so the default takes effect on the initial render.

Server-side the value falls back to `defaultValue` when no `value` is
given, so SSR and hydration agree.
---
 .changeset/tall-hounds-tap.md                 |  5 ++
 packages/svelte/elements.d.ts                 |  3 +
 .../client/visitors/RegularElement.js         | 23 ++++++
 .../server/visitors/RegularElement.js         |  2 +-
 .../client/dom/elements/attributes.js         | 27 ++++++-
 .../client/dom/elements/bindings/select.js    |  2 +-
 packages/svelte/src/internal/client/index.js  |  1 +
 .../svelte/src/internal/server/renderer.js    |  7 +-
 .../form-default-value-select/_config.js      | 70 +++++++++++++++++++
 .../form-default-value-select/main.svelte     | 38 ++++++++++
 10 files changed, 173 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/tall-hounds-tap.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte

diff --git a/.changeset/tall-hounds-tap.md b/.changeset/tall-hounds-tap.md
new file mode 100644
index 0000000000..3a9f7d79cb
--- /dev/null
+++ b/.changeset/tall-hounds-tap.md
@@ -0,0 +1,5 @@
+---
+'svelte': minor
+---
+
+feat: support `defaultValue` on `<select>`
diff --git a/packages/svelte/elements.d.ts b/packages/svelte/elements.d.ts
index daa40635b6..15837f831a 100644
--- a/packages/svelte/elements.d.ts
+++ b/packages/svelte/elements.d.ts
@@ -1352,6 +1352,9 @@ export interface HTMLSelectAttributes extends HTMLAttributes<HTMLSelectElement>
 	required?: boolean | undefined | null;
 	size?: number | undefined | null;
 	value?: any;
+	// needs both casing variants because language tools does lowercase names of non-shorthand attributes
+	defaultValue?: any;
+	defaultvalue?: any;
 
 	'on:change'?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
 	onchange?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
index 8dcd3c7d6f..451210f946 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
@@ -231,6 +231,12 @@ export function RegularElement(node, context) {
 				continue;
 			}
 
+			// `<select defaultValue>` needs the options to exist before it can mark one
+			// as selected, so it is handled after the children, alongside `value`
+			if (node.name === 'select' && attribute.name === 'defaultValue') {
+				continue;
+			}
+
 			const name = get_attribute_name(node, attribute);
 
 			if (
@@ -513,6 +519,23 @@ export function RegularElement(node, context) {
 		}
 	}
 
+	// deferred from the attribute loop above, so that the options it selects from
+	// have been created and had their values assigned
+	if (!has_spread && name === 'select') {
+		for (const attribute of /** @type {AST.Attribute[]} */ (attributes)) {
+			if (attribute.name === 'defaultValue') {
+				const { value, has_state } = build_attribute_value(attribute.value, context, (v, m) =>
+					context.state.memoizer.add(v, m)
+				);
+
+				const update = b.stmt(b.call('$.set_default_select_value', node_id, value));
+
+				(has_state ? context.state.update : context.state.init).push(update);
+				break;
+			}
+		}
+	}
+
 	context.state.template.pop_element();
 }
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
index 90c34d7035..2f312912bc 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
@@ -46,7 +46,7 @@ export function RegularElement(node, context) {
 		node.attributes.some(
 			(attribute) =>
 				((attribute.type === 'Attribute' || attribute.type === 'BindDirective') &&
-					attribute.name === 'value') ||
+					(attribute.name === 'value' || attribute.name === 'defaultValue')) ||
 				attribute.type === 'SpreadAttribute'
 		);
 	const is_option_special = name === 'option';
diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index 589685b5f2..2df6d3e68d 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -26,7 +26,8 @@ import { set_class } from './class.js';
 import { set_style } from './style.js';
 import { ATTACHMENT_KEY, NAMESPACE_HTML, UNINITIALIZED } from '../../../../constants.js';
 import { branch, destroy_effect, effect, managed } from '../../reactivity/effects.js';
-import { init_select, select_option } from './bindings/select.js';
+import { get_option_value, init_select, select_option } from './bindings/select.js';
+import { is } from '../../proxy.js';
 import { flatten } from '../../reactivity/async.js';
 
 export const CLASS = Symbol('class');
@@ -163,6 +164,30 @@ export function set_default_value(element, value) {
 	element.value = existing_value;
 }
 
+/**
+ * `<select>` has no `defaultValue` property. The default selection is instead
+ * expressed through the `selected` attribute of the matching `<option>`, which is
+ * what the form reset algorithm restores, so mark that option and unmark the rest.
+ * The current selection is preserved, since `selected` is the default state only.
+ * @param {HTMLSelectElement} select
+ * @param {any} value
+ */
+export function set_default_select_value(select, value) {
+	// `__value` is set by `<select value>` / `bind:value`. If it is absent, nothing has
+	// asked for a particular option yet, so the default selection should take effect —
+	// which is what the browser does with a `selected` attribute in the markup.
+	var has_explicit_value = '__value' in select;
+	var selected_index = select.selectedIndex;
+
+	for (var option of select.options) {
+		set_selected(option, is(get_option_value(option), value));
+	}
+
+	if (has_explicit_value) {
+		select.selectedIndex = selected_index;
+	}
+}
+
 /**
  * @param {Element} element
  * @param {string} attribute
diff --git a/packages/svelte/src/internal/client/dom/elements/bindings/select.js b/packages/svelte/src/internal/client/dom/elements/bindings/select.js
index e390e23ea0..44d50a7c7e 100644
--- a/packages/svelte/src/internal/client/dom/elements/bindings/select.js
+++ b/packages/svelte/src/internal/client/dom/elements/bindings/select.js
@@ -156,7 +156,7 @@ export function bind_select_value(select, get, set = get) {
 }
 
 /** @param {HTMLOptionElement} option */
-function get_option_value(option) {
+export function get_option_value(option) {
 	// __value only exists if the <option> has a value attribute
 	if ('__value' in option) {
 		return option.__value;
diff --git a/packages/svelte/src/internal/client/index.js b/packages/svelte/src/internal/client/index.js
index fa6f9dda39..38837bdfc4 100644
--- a/packages/svelte/src/internal/client/index.js
+++ b/packages/svelte/src/internal/client/index.js
@@ -36,6 +36,7 @@ export {
 	set_selected,
 	set_default_checked,
 	set_default_value,
+	set_default_select_value,
 	CLASS,
 	STYLE
 } from './dom/elements/attributes.js';
diff --git a/packages/svelte/src/internal/server/renderer.js b/packages/svelte/src/internal/server/renderer.js
index 35aac64721..93a9a365a1 100644
--- a/packages/svelte/src/internal/server/renderer.js
+++ b/packages/svelte/src/internal/server/renderer.js
@@ -332,11 +332,14 @@ export class Renderer {
 	 * @returns {void}
 	 */
 	select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
-		const { value, ...select_attrs } = attrs;
+		// the attribute name is lowercased by the compiler, as with any HTML attribute
+		const { value, defaultvalue, ...select_attrs } = attrs;
 
 		this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
 		this.child((renderer) => {
-			renderer.local.select_value = value;
+			// `<select>` has no defaultValue attribute — it only says which option is
+			// selected by default, so it applies when there is no `value` to override it
+			renderer.local.select_value = value === undefined ? defaultvalue : value;
 			fn(renderer);
 		});
 		this.push(`${is_rich ? '<!>' : ''}</select>`);
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js
new file mode 100644
index 0000000000..b4197e15e6
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js
@@ -0,0 +1,70 @@
+import { test } from '../../test';
+import { flushSync } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		/**
+		 * @param {NodeListOf<any>} options
+		 * @param {any[]} selected
+		 */
+		function check_options(options, selected) {
+			for (let i = 0; i < options.length; i++) {
+				assert.equal(options[i].selected, selected[i], `option ${i}`);
+			}
+		}
+
+		/**
+		 * @param {HTMLOptionElement} option
+		 */
+		function select_option(option) {
+			option.selected = true;
+			option.dispatchEvent(new Event('change', { bubbles: true }));
+		}
+
+		const reset = /** @type {HTMLInputElement} */ (target.querySelector('input[type=reset]'));
+		const [test1, test2, test3] = target.querySelectorAll('select');
+		const [test1_span, test2_span, test3_span] = target.querySelectorAll('span');
+
+		// defaultValue selects the matching option when no value is given
+		{
+			const options = test1.querySelectorAll('option');
+			check_options(options, [false, true, false]);
+			assert.htmlEqual(test1_span.innerHTML, 'b');
+		}
+
+		// an explicit value wins over defaultValue, but reset goes back to defaultValue
+		{
+			const options = test2.querySelectorAll('option');
+			check_options(options, [false, false, true]);
+			assert.htmlEqual(test2_span.innerHTML, 'c');
+		}
+
+		// static defaultValue behaves the same as the dynamic one
+		{
+			const options = test3.querySelectorAll('option');
+			check_options(options, [false, true, false]);
+			assert.htmlEqual(test3_span.innerHTML, 'b');
+		}
+
+		// change the selection, then reset the form
+		select_option(test1.querySelectorAll('option')[2]);
+		select_option(test2.querySelectorAll('option')[0]);
+		select_option(test3.querySelectorAll('option')[2]);
+		flushSync();
+
+		assert.htmlEqual(test1_span.innerHTML, 'c');
+		assert.htmlEqual(test2_span.innerHTML, 'a');
+		assert.htmlEqual(test3_span.innerHTML, 'c');
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+
+		check_options(test1.querySelectorAll('option'), [false, true, false]);
+		check_options(test2.querySelectorAll('option'), [false, true, false]);
+		check_options(test3.querySelectorAll('option'), [false, true, false]);
+		assert.htmlEqual(test1_span.innerHTML, 'b');
+		assert.htmlEqual(test2_span.innerHTML, 'b');
+		assert.htmlEqual(test3_span.innerHTML, 'b');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte
new file mode 100644
index 0000000000..944b9db1e7
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte
@@ -0,0 +1,38 @@
+<script>
+	let selected1 = $state();
+	let selected2 = $state('c');
+	let selected3 = $state();
+
+	let defaultValue = $state('b');
+</script>
+
+<form>
+	<!-- defaultValue=b, value=undefined -->
+	<select {defaultValue} bind:value={selected1}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<!-- defaultValue=b, value=c -->
+	<select {defaultValue} bind:value={selected2}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<!-- static defaultValue -->
+	<select defaultValue="b" bind:value={selected3}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<input type="reset" value="Reset" />
+</form>
+
+<p>
+	<span class="test-1">{selected1}</span>
+	<span class="test-2">{selected2}</span>
+	<span class="test-3">{selected3}</span>
+</p>

From 22c07e69bcc5eb5acd03c8a7ae66be4d143671d1 Mon Sep 17 00:00:00 2001
From: Socialpranker <273312799+Socialpranker@users.noreply.github.com>
Date: Tue, 28 Jul 2026 13:09:44 +0200
Subject: [PATCH 2/3] fix: apply `<select defaultValue>` when the element is
 spread

The client only handled `defaultValue` in the non-spread path, so
`<select {...props}>` compiled to `attribute_effect` and never reached
`set_default_select_value`. `set_attributes` can't apply it either,
since assigning the property does nothing on a select. It now marks the
default option from the same effect that handles `value`, after the
options exist.

Server-side the key was only read as `defaultvalue`. That is what the
compiler emits for an attribute written in the template, but a spread
passes keys through as the user wrote them, so `defaultValue` was
ignored and SSR disagreed with the client. Both spellings are accepted
now.

This is the case #18447 was filed for: `<select {...form.fields.x.as('select')}>`
in SvelteKit is always a spread.
---
 .../client/dom/elements/attributes.js         | 11 +++-
 .../svelte/src/internal/server/renderer.js    |  8 ++-
 .../_config.js                                | 56 +++++++++++++++++++
 .../main.svelte                               | 26 +++++++++
 .../select-default-value/_expected.html       | 12 ++++
 .../samples/select-default-value/main.svelte  | 18 ++++++
 6 files changed, 127 insertions(+), 4 deletions(-)
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/main.svelte
 create mode 100644 packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html
 create mode 100644 packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte

diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index 2df6d3e68d..dc66a9c071 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -584,7 +584,16 @@ export function attribute_effect(
 			var select = /** @type {HTMLSelectElement} */ (element);
 
 			effect(() => {
-				select_option(select, /** @type {Record<string | symbol, any>} */ (prev).value, true);
+				var attrs = /** @type {Record<string | symbol, any>} */ (prev);
+
+				// `defaultValue` is meaningless as a property here, so `set_attributes` cannot
+				// apply it. Mark the default option once the options exist, as we do for the
+				// non-spread case.
+				if ('defaultValue' in attrs) {
+					set_default_select_value(select, attrs.defaultValue);
+				}
+
+				select_option(select, attrs.value, true);
 				init_select(select);
 			});
 		}
diff --git a/packages/svelte/src/internal/server/renderer.js b/packages/svelte/src/internal/server/renderer.js
index 93a9a365a1..96f66695c2 100644
--- a/packages/svelte/src/internal/server/renderer.js
+++ b/packages/svelte/src/internal/server/renderer.js
@@ -332,14 +332,16 @@ export class Renderer {
 	 * @returns {void}
 	 */
 	select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
-		// the attribute name is lowercased by the compiler, as with any HTML attribute
-		const { value, defaultvalue, ...select_attrs } = attrs;
+		// the compiler lowercases attribute names written in the template, but a spread
+		// passes the keys through as the user wrote them, so accept both spellings
+		const { value, defaultValue, defaultvalue, ...select_attrs } = attrs;
+		const default_value = defaultValue === undefined ? defaultvalue : defaultValue;
 
 		this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
 		this.child((renderer) => {
 			// `<select>` has no defaultValue attribute — it only says which option is
 			// selected by default, so it applies when there is no `value` to override it
-			renderer.local.select_value = value === undefined ? defaultvalue : value;
+			renderer.local.select_value = value === undefined ? default_value : value;
 			fn(renderer);
 		});
 		this.push(`${is_rich ? '<!>' : ''}</select>`);
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/_config.js b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/_config.js
new file mode 100644
index 0000000000..a0d8ba5b46
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/_config.js
@@ -0,0 +1,56 @@
+import { test } from '../../test';
+import { flushSync } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		/**
+		 * @param {NodeListOf<any>} options
+		 * @param {any[]} selected
+		 */
+		function check_options(options, selected) {
+			for (let i = 0; i < options.length; i++) {
+				assert.equal(options[i].selected, selected[i], `option ${i}`);
+			}
+		}
+
+		/**
+		 * @param {HTMLOptionElement} option
+		 */
+		function select_option(option) {
+			option.selected = true;
+			option.dispatchEvent(new Event('change', { bubbles: true }));
+		}
+
+		const reset = /** @type {HTMLInputElement} */ (target.querySelector('input[type=reset]'));
+		const [test1, test2] = target.querySelectorAll('select');
+		const [test1_span] = target.querySelectorAll('span');
+
+		// a spread carrying defaultValue selects the matching option
+		{
+			const options = test1.querySelectorAll('option');
+			check_options(options, [false, true, false]);
+			assert.htmlEqual(test1_span.innerHTML, 'b');
+		}
+
+		// value in the same spread still wins over defaultValue
+		{
+			const options = test2.querySelectorAll('option');
+			check_options(options, [false, false, true]);
+		}
+
+		// changing the selection and resetting goes back to defaultValue
+		select_option(test1.querySelectorAll('option')[2]);
+		select_option(test2.querySelectorAll('option')[0]);
+		flushSync();
+
+		assert.htmlEqual(test1_span.innerHTML, 'c');
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+
+		check_options(test1.querySelectorAll('option'), [false, true, false]);
+		check_options(test2.querySelectorAll('option'), [false, true, false]);
+		assert.htmlEqual(test1_span.innerHTML, 'b');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/main.svelte b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/main.svelte
new file mode 100644
index 0000000000..287db5e9a3
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-spread/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let props1 = $state({ defaultValue: 'b' });
+	let props2 = $state({ defaultValue: 'b', value: 'c' });
+
+	let selected = $state();
+</script>
+
+<form>
+	<!-- spread carrying defaultValue, no value -->
+	<select {...props1} bind:value={selected}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<!-- spread carrying both, value wins -->
+	<select {...props2}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<input type="reset" value="Reset" />
+</form>
+
+<p><span class="test-1">{selected}</span></p>
diff --git a/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html b/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html
new file mode 100644
index 0000000000..c2ccbafd2a
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html
@@ -0,0 +1,12 @@
+<select>
+	<option value="a">A</option>
+	<option selected="" value="b">B</option>
+</select>
+<select>
+	<option value="a">A</option>
+	<option selected="" value="b">B</option>
+</select>
+<select>
+	<option selected="" value="a">A</option>
+	<option value="b">B</option>
+</select>
diff --git a/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte b/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte
new file mode 100644
index 0000000000..ca3fc36a35
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte
@@ -0,0 +1,18 @@
+<script>
+	const props = { defaultValue: 'b' };
+</script>
+
+<select defaultValue="b">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select {...props}>
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select defaultValue="b" value="a">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>

From 72eef03b23bc66090f1fd1d1143a829ef874a7dc Mon Sep 17 00:00:00 2001
From: Socialpranker <273312799+Socialpranker@users.noreply.github.com>
Date: Sat, 1 Aug 2026 13:03:44 +0200
Subject: [PATCH 3/3] fix: apply `<select multiple defaultValue>` by membership

`set_default_select_value` compared every option against the whole value,
so a `multiple` select never matched and its default selection was lost.
Mirror `select_option` instead: branch on `select.multiple` and test
membership, leaving a non-array value alone.

Restoring `selectedIndex` only preserves a single selection, so the
multiple branch snapshots `selectedOptions` and restores each option,
keeping the current selection untouched.
---
 .../client/dom/elements/attributes.js         | 23 +++++++-
 .../_config.js                                | 55 +++++++++++++++++++
 .../main.svelte                               | 27 +++++++++
 3 files changed, 104 insertions(+), 1 deletion(-)
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/main.svelte

diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index dc66a9c071..083dfcbd4d 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -1,7 +1,7 @@
 /** @import { Blocker, Effect } from '#client' */
 import { DEV } from 'esm-env';
 import { hydrating, set_hydrating } from '../hydration.js';
-import { get_descriptors, get_prototype_of } from '../../../shared/utils.js';
+import { get_descriptors, get_prototype_of, is_array } from '../../../shared/utils.js';
 import { create_event, delegate, delegated, event, event_symbol } from './events.js';
 import { add_form_reset_listener, autofocus } from './misc.js';
 import * as w from '../../warnings.js';
@@ -179,6 +179,27 @@ export function set_default_select_value(select, value) {
 	var has_explicit_value = '__value' in select;
 	var selected_index = select.selectedIndex;
 
+	if (select.multiple) {
+		// a `multiple` select takes a list of values, so an option is part of the
+		// default selection when it is a member of that list — mirroring how
+		// `select_option` applies the current value
+		if (!is_array(value)) return;
+
+		var selected = new Set([...select.selectedOptions]);
+
+		for (var multi_option of select.options) {
+			set_selected(multi_option, value.includes(get_option_value(multi_option)));
+		}
+
+		if (has_explicit_value) {
+			for (var option_to_restore of select.options) {
+				option_to_restore.selected = selected.has(option_to_restore);
+			}
+		}
+
+		return;
+	}
+
 	for (var option of select.options) {
 		set_selected(option, is(get_option_value(option), value));
 	}
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/_config.js b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/_config.js
new file mode 100644
index 0000000000..c220aa0d8a
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/_config.js
@@ -0,0 +1,55 @@
+import { test } from '../../test';
+import { flushSync } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		/**
+		 * @param {NodeListOf<any>} options
+		 * @param {any[]} selected
+		 */
+		function check_options(options, selected) {
+			for (let i = 0; i < options.length; i++) {
+				assert.equal(options[i].selected, selected[i], `option ${i}`);
+			}
+		}
+
+		/**
+		 * @param {HTMLSelectElement} select
+		 * @param {number[]} indexes
+		 */
+		function select_options(select, indexes) {
+			const options = select.querySelectorAll('option');
+			for (let i = 0; i < options.length; i++) {
+				options[i].selected = indexes.includes(i);
+			}
+			select.dispatchEvent(new Event('change', { bubbles: true }));
+		}
+
+		const reset = /** @type {HTMLInputElement} */ (target.querySelector('input[type=reset]'));
+		const [test1, test2] = target.querySelectorAll('select');
+		const span = /** @type {HTMLSpanElement} */ (target.querySelector('span'));
+
+		// every option named by defaultValue is selected, not just none of them
+		check_options(test1.querySelectorAll('option'), [true, false, true]);
+
+		// an explicit value still wins over defaultValue
+		check_options(test2.querySelectorAll('option'), [false, false, true]);
+		assert.htmlEqual(span.innerHTML, 'c');
+
+		// change both selections, then reset the form
+		select_options(test1, [1]);
+		select_options(test2, [0, 1]);
+		flushSync();
+
+		assert.htmlEqual(span.innerHTML, 'a,b');
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+
+		// reset restores the default selection in both cases
+		check_options(test1.querySelectorAll('option'), [true, false, true]);
+		check_options(test2.querySelectorAll('option'), [true, false, true]);
+		assert.htmlEqual(span.innerHTML, 'a,c');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/main.svelte b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/main.svelte
new file mode 100644
index 0000000000..c214e3ba10
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select-multiple/main.svelte
@@ -0,0 +1,27 @@
+<script>
+	let selected = $state(['c']);
+
+	let defaultValue = $state(['a', 'c']);
+</script>
+
+<form>
+	<!-- defaultValue=[a, c], no value: the default selection takes effect -->
+	<select multiple {defaultValue}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<!-- defaultValue=[a, c], value=[c]: the explicit value wins -->
+	<select multiple {defaultValue} bind:value={selected}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<input type="reset" value="Reset" />
+</form>
+
+<p>
+	<span class="test-1">{selected.join(',')}</span>
+</p>