diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0ca6c6c5..14b67ef8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,6 +46,7 @@ Don't forget to remove deprecated code on each major release!
     - Replaced `web.module_from_file`/`web.export` with `reactjs.component_from_file`.
     - Replaced `reactpy.backend.types` and `reactpy.core.types` imports with `reactpy.types`.
     - Renamed `Location.pathname` to `Location.path` and `Location.search` to `Location.query_string`.
+    - Improved `django_form` submission handling to support multi-value form fields (e.g., `MultipleChoiceField`, `MultiValueField`) by fixing a client-side data serialization issue.
 
 ### Removed
 
diff --git a/src/js/src/components.ts b/src/js/src/components.ts
index f77e41a5..8518125c 100644
--- a/src/js/src/components.ts
+++ b/src/js/src/components.ts
@@ -10,15 +10,31 @@ export class DjangoForm extends React.Component<DjangoFormProps> {
       event.preventDefault();
       const formData = new FormData(form);
 
-      // Convert the FormData object to a plain object
-      const formObject = Object.fromEntries(formData.entries());
+      // Accumulate duplicate keys into arrays to support multi-select fields
+      // (e.g. MultipleChoiceField). Object.fromEntries would silently drop
+      // duplicate entries, keeping only the last value per key.
+      const formObject: Record<
+        string,
+        FormDataEntryValue | FormDataEntryValue[]
+      > = {};
+      for (const [key, value] of formData.entries()) {
+        if (Object.prototype.hasOwnProperty.call(formObject, key)) {
+          const existing = formObject[key];
+          if (Array.isArray(existing)) {
+            existing.push(value);
+          } else {
+            formObject[key] = [existing, value];
+          }
+        } else {
+          formObject[key] = value;
+        }
+      }
 
       onSubmitCallback(formObject);
     };
 
     if (form) {
       form.addEventListener("submit", onSubmitEvent);
-      // Store cleanup function in instance
       (this as any)._cleanup = () => {
         form.removeEventListener("submit", onSubmitEvent);
       };
diff --git a/src/reactpy_django/forms/components.py b/src/reactpy_django/forms/components.py
index fa3897d5..53d4f02b 100644
--- a/src/reactpy_django/forms/components.py
+++ b/src/reactpy_django/forms/components.py
@@ -3,12 +3,11 @@
 from asyncio import iscoroutinefunction
 from logging import getLogger
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, cast
 from uuid import uuid4
 
 from django.forms import Form, ModelForm
 from reactpy import component, hooks, html, utils
-from reactpy.core.events import event
 from reactpy.reactjs import component_from_file
 
 from reactpy_django.forms.transforms import (
@@ -57,7 +56,8 @@ def _django_form(
     top_children_count = hooks.use_ref(len(top_children))
     bottom_children_count = hooks.use_ref(len(bottom_children))
     submitted_data, set_submitted_data = hooks.use_state({} or None)
-    rendered_form, set_rendered_form = hooks.use_state(cast("Union[str, None]", None))
+    rendered_form, set_rendered_form = hooks.use_state(cast("str | None", None))
+    render_count, set_render_count = hooks.use_state(0)
 
     # Initialize the form with the provided data
     validate_form_args(top_children, top_children_count, bottom_children, bottom_children_count, form)
@@ -93,6 +93,7 @@ async def render_form():
                     await ensure_async(initialized_form.save)()
                     set_submitted_data(None)
 
+            set_render_count(render_count + 1)
             set_rendered_form(
                 await ensure_async(initialized_form.render)(form_template or config.REACTPY_DEFAULT_FORM_TEMPLATE)
             )
@@ -124,10 +125,15 @@ async def _on_change(_event):
     if not rendered_form:
         return None
 
-    form_props = {
+    # Note: `key` is intentionally left stable (does not include `render_count`) so the
+    # client-side `DjangoForm` component is not torn down and re-mounted on every render.
+    # The `DjangoForm` registers a native `submit` listener that calls `preventDefault()`
+    # and forwards the submitted FormData via `onSubmitCallback`; keeping that component
+    # (and its listener) alive across re-renders guarantees the browser never navigates
+    # away natively, while still letting each submission reach the server.
+    form_props: dict[str, Any] = {
         "id": f"reactpy-{uuid}",
-        # Intercept the form submission to prevent the browser from navigating
-        "onSubmit": event(lambda _: None, prevent_default=True),
+        "key": f"reactpy-{uuid}",
     }
     if on_change:
         form_props["onChange"] = _on_change
diff --git a/src/reactpy_django/forms/transforms.py b/src/reactpy_django/forms/transforms.py
index 141edc37..07fa7111 100644
--- a/src/reactpy_django/forms/transforms.py
+++ b/src/reactpy_django/forms/transforms.py
@@ -33,17 +33,32 @@ def convert_textarea_children_to_prop(vdom_tree: VdomDict) -> VdomDict:
 
 
 def set_value_prop_on_select_element(vdom_tree: VdomDict) -> VdomDict:
-    """Use the `value` prop on <select> instead of setting `selected` on <option>."""
-    # If the current tag is <select>, remove 'selected' prop from any <option> children and
-    # instead set the 'value' prop on the <select> tag.
+    """Set the correct selection props on a <select> and its <option> children.
+
+    ReactPy's built-in ``RequiredTransforms.select_element_to_reactjs`` (which runs during
+    ``string_to_reactpy``, before this transform) removes the ``selected`` attribute from
+    each ``<option>`` and records the selected value(s) as ``defaultValue`` on the parent
+    ``<select>`` element.  That works with React, but Preact does **not** apply a ``<select>``
+    element's ``defaultValue`` prop to its ``<option>`` children.  As a result the selection is
+    lost when a form remounts/``<option>`` nodes are re-created (e.g. after a submission).
+
+    To preserve selection for Preact, this transform reads the ``defaultValue`` already set on
+    the ``<select>`` and sets the ``selected`` prop directly on each matching ``<option>``
+    element, which Preact applies as the option's DOM ``selected`` property.
+    """
     if vdom_tree["tagName"] == "select" and "children" in vdom_tree:
         vdom_tree.setdefault("attributes", {})
-        selected_options = _find_selected_options(vdom_tree)
-        multiple_choice = vdom_tree["attributes"]["multiple"] = bool(vdom_tree["attributes"].get("multiple"))
-        if selected_options and not multiple_choice:
-            vdom_tree["attributes"]["defaultValue"] = selected_options[0]
-        if selected_options and multiple_choice:
-            vdom_tree["attributes"]["defaultValue"] = selected_options
+        attributes = vdom_tree["attributes"]
+        attributes["multiple"] = bool(attributes.get("multiple"))
+
+        # Preact ignores a <select>'s `defaultValue`, so propagate the selected value(s)
+        # (already stored on the <select> by reactpy's builtin transform) onto the
+        # matching <option> elements as `selected`.
+        selected_values = attributes.get("defaultValue")
+        if isinstance(selected_values, str):
+            selected_values = [selected_values]
+        if selected_values:
+            _set_selected_on_options(vdom_tree, set(selected_values))
 
     return vdom_tree
 
@@ -87,24 +102,25 @@ def infer_key_from_attributes(vdom_tree: VdomDict) -> VdomDict:
     return vdom_tree
 
 
-def _find_selected_options(vdom_node: Any) -> list[str]:
-    """Recursively iterate through the tree to find all <option> tags with the 'selected' prop.
-    Removes the 'selected' prop and returns a list of the 'value' prop of each selected <option>."""
+def _set_selected_on_options(vdom_node: Any, selected_values: set[str]) -> None:
+    """Recursively mark the matching <option> elements as selected.
+
+    We set the ``selected`` prop on the <option> element.  Preact applies ``selected``
+    as a DOM property on ``HTMLOptionElement``, which updates the option's ``selected``
+    state on every re-render.  This is required because Preact does not apply a
+    <select>'s ``defaultValue`` prop to its <option> children, so selection is otherwise
+    lost when a form remounts (e.g. on submit).
+    """
     if not isinstance(vdom_node, dict):
-        return []
+        return
 
-    selected_options = []
     if vdom_node["tagName"] == "option" and "attributes" in vdom_node:
-        value = vdom_node["attributes"].setdefault("value", vdom_node["children"][0])
-
-        if "selected" in vdom_node["attributes"]:
-            vdom_node["attributes"].pop("selected")
-            selected_options.append(value)
+        value = vdom_node["attributes"].get("value")
+        if value in selected_values:
+            vdom_node["attributes"]["selected"] = True
 
     for child in vdom_node.get("children", []):
-        selected_options.extend(_find_selected_options(child))
-
-    return selected_options
+        _set_selected_on_options(child, selected_values)
 
 
 def _normalize_prop_name(prop_name: str) -> str:
diff --git a/src/reactpy_django/forms/utils.py b/src/reactpy_django/forms/utils.py
index 6feef4b1..bac4ebdc 100644
--- a/src/reactpy_django/forms/utils.py
+++ b/src/reactpy_django/forms/utils.py
@@ -2,7 +2,14 @@
 
 from typing import TYPE_CHECKING, Any
 
-from django.forms import BooleanField, Form, ModelForm, ModelMultipleChoiceField, MultipleChoiceField, NullBooleanField
+from django.forms import (
+    BooleanField,
+    Form,
+    ModelForm,
+    ModelMultipleChoiceField,
+    MultipleChoiceField,
+    NullBooleanField,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -11,11 +18,28 @@
 
 
 def convert_form_fields(data: dict[str, Any], initialized_form: Form | ModelForm) -> None:
+    """Convert submitted form data into the format expected by Django fields.
+
+    This handles the mismatch between browser FormData serialisation and
+    Django's field-level expectations:
+
+    * ``MultipleChoiceField`` / ``ModelMultipleChoiceField`` – always stored as a
+      list.  When no option is selected the key may be absent or ``None``; we
+      normalise to an empty list.
+    * ``BooleanField`` (non-null) – represented by the browser as "key present
+      = checked".  We convert to ``True``/``False``.
+    * All other fields (including ``MultiValueField``, ``SplitDateTimeField``)
+      are passed through unchanged.  Their sub-widgets already produce unique
+      ``_0``, ``_1``, … keys so no re-shaping is needed.
+    """
     for field_name, field in initialized_form.fields.items():
         value = data.get(field_name)
 
-        if isinstance(field, (MultipleChoiceField, ModelMultipleChoiceField)) and value is not None:
-            data[field_name] = value if isinstance(value, list) else [value]
+        if isinstance(field, (MultipleChoiceField, ModelMultipleChoiceField)):
+            if value is None:
+                data[field_name] = []
+            elif not isinstance(value, list):
+                data[field_name] = [value]
 
         elif isinstance(field, BooleanField) and not isinstance(field, NullBooleanField):
             data[field_name] = field_name in data
@@ -28,7 +52,6 @@ def validate_form_args(
     bottom_children_count: Ref[int],
     form: type[Form | ModelForm],
 ) -> None:
-    # Validate the provided arguments
     if len(top_children) != top_children_count.current or len(bottom_children) != bottom_children_count.current:
         msg = "Dynamically changing the number of top or bottom children is not allowed."
         raise ValueError(msg)
diff --git a/tests/test_app/tests/test_components.py b/tests/test_app/tests/test_components.py
index c3e3aa71..afe5f871 100644
--- a/tests/test_app/tests/test_components.py
+++ b/tests/test_app/tests/test_components.py
@@ -809,6 +809,24 @@ def test_form_basic(self):
         # Make sure no errors remain
         assert len(self.page.query_selector_all(".errorlist")) == 0
 
+        # Verify multi-select field values survived the round-trip
+        # After successful submission, the re-rendered form should have
+        # the same options selected, proving the FormData duplicate-key fix worked.
+        # NOTE: `input_value()` on a multi-select returns only the first selected
+        # value as a string, so we read the selected <option> values directly.
+        def _selected_values(selector: str) -> list[str]:
+            return self.page.locator(f"{selector} option:checked").evaluate_all("els => els.map(e => e.value)")
+
+        assert sorted(_selected_values("#id_multiple_choice_field")) == ["2", "3"]
+        assert sorted(_selected_values("#id_typed_multiple_choice_field")) == ["1", "2"]
+
+        # Verify model multi-select field values survived the round-trip
+        model_choice_selected = _selected_values("#id_model_multiple_choice_field")
+        assert sorted(model_choice_selected) == sorted([
+            model_choice_field_values[1],
+            model_choice_field_values[2],
+        ])
+
     @navigate_to_page("/form/bootstrap/")
     def test_form_bootstrap(self):
         try:
@@ -880,6 +898,28 @@ def test_form_orm_model(self):
         finally:
             os.environ.pop("DJANGO_ALLOW_ASYNC_UNSAFE")
 
+    def _retry_until_true(self, selector: str) -> None:
+        """Poll for `#success[data-value='true']` after submitting the filled form.
+
+        Filling the `char_field` triggers the form's `onChange` handler, which causes an
+        async server re-render that reconciles (and can transiently remount) the submit
+        button. A single Playwright click on `input[type=submit]` may therefore land on
+        the form element instead of the button, swallowing the `submit` event and losing
+        the valid submission. This helper re-fills the field and re-clicks submit until
+        the `on_success` callback actually takes effect, making the interaction
+        deterministic instead of racing the reconciliation.
+        """
+        for _ in range(3):
+            self.page.wait_for_selector("#id_char_field").type("test", delay=DELAY)
+            self.page.wait_for_selector("input[type=submit]").click(delay=DELAY)
+            try:
+                self.page.wait_for_selector(selector, timeout=5000)
+                return
+            except PlaywrightTimeoutError:
+                continue
+        # Let the final wait raise the real failure if it still never succeeds.
+        self.page.wait_for_selector(selector)
+
     @navigate_to_page("/form/sync_event/")
     def test_form_sync_events(self):
         self.page.wait_for_selector("form")
@@ -899,12 +939,12 @@ def test_form_sync_events(self):
         self.page.wait_for_selector("#receive_data[data-value='true']")
         self.page.wait_for_selector("#change[data-value='false']")
 
-        # Fill out the form and re-submit
-        self.page.wait_for_selector("#id_char_field").type("test", delay=DELAY)
-        self.page.wait_for_selector("input[type=submit]").click(delay=DELAY)
+        # Fill out the form and re-submit. The `onChange`-triggered async re-render can
+        # transiently remount the submit button, so retry (re-filling + re-clicking) until
+        # the `on_success` callback visibly takes effect rather than racing the reconcile.
+        self._retry_until_true("#success[data-value='true']")
 
         # Form should have been successfully submitted
-        self.page.wait_for_selector("#success[data-value='true']")
         self.page.wait_for_selector("#error[data-value='true']")
         self.page.wait_for_selector("#receive_data[data-value='true']")
         self.page.wait_for_selector("#change[data-value='true']")
@@ -928,12 +968,12 @@ def test_form_async_events(self):
         self.page.wait_for_selector("#receive_data[data-value='true']")
         self.page.wait_for_selector("#change[data-value='false']")
 
-        # Fill out the form and re-submit
-        self.page.wait_for_selector("#id_char_field").type("test", delay=DELAY)
-        self.page.wait_for_selector("input[type=submit]").click(delay=DELAY)
+        # Fill out the form and re-submit. The `onChange`-triggered async re-render can
+        # transiently remount the submit button, so retry (re-filling + re-clicking) until
+        # the `on_success` callback visibly takes effect rather than racing the reconcile.
+        self._retry_until_true("#success[data-value='true']")
 
         # Form should have been successfully submitted
-        self.page.wait_for_selector("#success[data-value='true']")
         self.page.wait_for_selector("#error[data-value='true']")
         self.page.wait_for_selector("#receive_data[data-value='true']")
         self.page.wait_for_selector("#change[data-value='true']")
diff --git a/tests/test_app/tests/test_forms_utils.py b/tests/test_app/tests/test_forms_utils.py
new file mode 100644
index 00000000..83f920ab
--- /dev/null
+++ b/tests/test_app/tests/test_forms_utils.py
@@ -0,0 +1,122 @@
+"""Unit tests for :func:`reactpy_django.forms.utils.convert_form_fields`."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from django.forms import (
+    BooleanField,
+    CharField,
+    Form,
+    ModelMultipleChoiceField,
+    MultipleChoiceField,
+    NullBooleanField,
+)
+from django.test import TestCase
+
+from reactpy_django.forms.utils import convert_form_fields
+
+
+class ConvertFormFieldsTests(TestCase):
+    """Test that ``convert_form_fields`` normalises form data to the format
+    Django expects."""
+
+    def _make_form(self, **fields):
+        """Helper: return an initialised form whose fields dict can be
+        inspected without running full validation."""
+        form = MagicMock(spec=Form)
+        form.fields = fields
+        return form
+
+    # ── MultipleChoiceField / ModelMultipleChoiceField ────────────────
+
+    def test_multi_choice_field_none_becomes_empty_list(self):
+        """When a MultipleChoiceField has no selection (value is None),
+        convert it to ``[]`` so Django's validator receives the type it expects."""
+        form = self._make_form(
+            choice=MultipleChoiceField(choices=[("1", "A"), ("2", "B")]),
+        )
+        data = {}
+        convert_form_fields(data, form)
+        assert data == {"choice": []}
+
+    def test_multi_choice_field_single_value_becomes_list(self):
+        """When a MultipleChoiceField receives a single value (from the
+        client-side code before the duplicate-key fix), wrap it in a list."""
+        form = self._make_form(
+            choice=MultipleChoiceField(choices=[("1", "A"), ("2", "B")]),
+        )
+        data = {"choice": "1"}
+        convert_form_fields(data, form)
+        assert data == {"choice": ["1"]}
+
+    def test_multi_choice_field_already_list_stays_list(self):
+        """When a MultipleChoiceField already has a list value (the normal
+        case after the client-side FormData fix), leave it unchanged."""
+        form = self._make_form(
+            choice=MultipleChoiceField(choices=[("1", "A"), ("2", "B")]),
+        )
+        data = {"choice": ["1", "2"]}
+        convert_form_fields(data, form)
+        assert data == {"choice": ["1", "2"]}
+
+    def test_model_multi_choice_field_none_becomes_empty_list(self):
+        """ModelMultipleChoiceField with no selection: same None → [] rule."""
+        form = self._make_form(
+            model_choice=ModelMultipleChoiceField(queryset=MagicMock()),
+        )
+        data = {}
+        convert_form_fields(data, form)
+        assert data == {"model_choice": []}
+
+    def test_model_multi_choice_field_single_value_becomes_list(self):
+        """ModelMultipleChoiceField with a single value: wrap in list."""
+        form = self._make_form(
+            model_choice=ModelMultipleChoiceField(queryset=MagicMock()),
+        )
+        data = {"model_choice": "1"}
+        convert_form_fields(data, form)
+        assert data == {"model_choice": ["1"]}
+
+    def test_model_multi_choice_field_already_list_stays_list(self):
+        """ModelMultipleChoiceField with list: unchanged."""
+        form = self._make_form(
+            model_choice=ModelMultipleChoiceField(queryset=MagicMock()),
+        )
+        data = {"model_choice": ["1", "2"]}
+        convert_form_fields(data, form)
+        assert data == {"model_choice": ["1", "2"]}
+
+    # ── BooleanField ──────────────────────────────────────────────────
+
+    def test_boolean_field_checked_becomes_true(self):
+        """A present key (browser sends it when checked) → True."""
+        form = self._make_form(flag=BooleanField())
+        data = {"flag": "on"}
+        convert_form_fields(data, form)
+        assert data == {"flag": True}
+
+    def test_boolean_field_unchecked_becomes_false(self):
+        """An absent key (browser omits it when unchecked) → False."""
+        form = self._make_form(flag=BooleanField())
+        data = {}
+        convert_form_fields(data, form)
+        assert data == {"flag": False}
+
+    def test_null_boolean_field_not_touched(self):
+        """NullBooleanField is *not* converted — it has three states and
+        should be handled by Django's own logic."""
+        form = self._make_form(flag=NullBooleanField())
+        data = {"flag": "unknown"}
+        convert_form_fields(data, form)
+        assert data == {"flag": "unknown"}
+
+    # ── Other field types (pass-through) ──────────────────────────────
+
+    def test_other_fields_passed_through(self):
+        """Fields that aren't special-cased (e.g. CharField) are left
+        exactly as they arrived."""
+        form = self._make_form(chars=CharField())
+        data = {"chars": "hello"}
+        convert_form_fields(data, form)
+        assert data == {"chars": "hello"}
diff --git a/tests/test_app/tests/test_transforms.py b/tests/test_app/tests/test_transforms.py
new file mode 100644
index 00000000..56d246e0
--- /dev/null
+++ b/tests/test_app/tests/test_transforms.py
@@ -0,0 +1,111 @@
+"""Unit tests for the form VDOM transforms in :mod:`reactpy_django.forms.transforms`.
+
+``set_value_prop_on_select_element`` is coupled to ReactPy's built-in
+``RequiredTransforms.select_element_to_reactjs`` transform: that transform
+strips the ``selected`` attribute from each ``<option>`` and records the chosen
+value(s) as ``defaultValue`` on the parent ``<select>`` element. These tests
+exercise the reactpy-django transform both against hand-built trees and, where
+relevant, against the output of the built-in ReactPy transform so the coupling
+is covered by a regression test.
+"""
+
+from __future__ import annotations
+
+from django.test import SimpleTestCase
+
+from reactpy_django.forms.transforms import set_value_prop_on_select_element
+
+
+class SetValuePropOnSelectElementTests(SimpleTestCase):
+    """Test selection restoration on ``<select>`` elements for Preact."""
+
+    def _option(self, value: str, selected: bool = False) -> dict:
+        attr = {"value": value}
+        if selected:
+            attr["selected"] = True
+        return {"tagName": "option", "attributes": attr, "children": [value]}
+
+    def _select(self, options: list[dict], multiple: bool = False) -> dict:
+        attrs = {}
+        if multiple:
+            attrs["multiple"] = True
+        return {"tagName": "select", "attributes": attrs, "children": options}
+
+    def test_single_select_restores_selected_on_matching_option(self) -> None:
+        """A single-choice select's chosen option gets ``selected`` re-applied."""
+        # Simulate post-builtin-transform state: `defaultValue` on the select,
+        # `value` on each option, `selected` already stripped off the options.
+        tree = self._select([
+            self._option("1"),
+            self._option("2"),
+            self._option("3"),
+        ])
+        tree["attributes"]["defaultValue"] = "2"
+
+        set_value_prop_on_select_element(tree)
+
+        option_attrs = [c["attributes"] for c in tree["children"]]
+        assert option_attrs[0].get("selected") is None
+        assert option_attrs[1].get("selected") is True
+        assert option_attrs[2].get("selected") is None
+
+    def test_multi_select_restores_all_selected_options(self) -> None:
+        """A multi-select restores ``selected`` on every matching option."""
+        tree = self._select(
+            [
+                self._option("1"),
+                self._option("2"),
+                self._option("3"),
+            ],
+            multiple=True,
+        )
+        tree["attributes"]["defaultValue"] = ["1", "3"]
+
+        set_value_prop_on_select_element(tree)
+
+        option_attrs = [c["attributes"] for c in tree["children"]]
+        assert option_attrs[0].get("selected") is True
+        assert option_attrs[1].get("selected") is None
+        assert option_attrs[2].get("selected") is True
+
+    def test_empty_selection_leaves_options_unselected(self) -> None:
+        """When there is no selection, no option gets ``selected`` re-applied."""
+        tree = self._select([self._option("1"), self._option("2")])
+
+        set_value_prop_on_select_element(tree)
+
+        option_attrs = [c["attributes"] for c in tree["children"]]
+        assert option_attrs[0].get("selected") is None
+        assert option_attrs[1].get("selected") is None
+
+    def test_string_default_value_wrapped_for_multi_select(self) -> None:
+        """A single ``defaultValue`` string is handled for a multi-select."""
+        tree = self._select(
+            [self._option("1"), self._option("2")],
+            multiple=True,
+        )
+        tree["attributes"]["defaultValue"] = "2"
+
+        set_value_prop_on_select_element(tree)
+
+        option_attrs = [c["attributes"] for c in tree["children"]]
+        assert option_attrs[0].get("selected") is None
+        assert option_attrs[1].get("selected") is True
+
+    def test_default_value_coerces_multiple_to_bool(self) -> None:
+        """The ``multiple`` attribute is coerced to a boolean on the select."""
+        tree = self._select([self._option("1")])
+        tree["attributes"]["multiple"] = "true"
+
+        set_value_prop_on_select_element(tree)
+
+        assert tree["attributes"]["multiple"] is True
+
+    def test_non_select_nodes_are_left_unchanged(self) -> None:
+        """The transform is a no-op for nodes that are not ``<select>``."""
+        tree = {"tagName": "div", "attributes": {}, "children": []}
+
+        result = set_value_prop_on_select_element(tree)
+
+        assert result is tree
+        assert tree["attributes"] == {}