@aurodesignsystem-dev/auro-formkit 0.0.0-pr1582.0 → 0.0.0-pr1582.2

package/components/combobox/demo/customize.min.js

@@ -4977,7 +4977,7 @@ let AuroHelpText$2 = class AuroHelpText extends i$3 {
   }
 };
 
-var formkitVersion$2 = '202608102106';
+var formkitVersion$2 = '202608111845';
 
 let AuroElement$2 = class AuroElement extends i$3 {
   static get properties() {
@@ -18677,7 +18677,7 @@ let AuroHelpText$1 = class AuroHelpText extends i$3 {
   }
 };
 
-var formkitVersion$1 = '202608102106';
+var formkitVersion$1 = '202608111845';
 
 // Copyright (c) 2025 Alaska Airlines. All right reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
@@ -18778,22 +18778,35 @@ class AuroInput extends BaseInput {
    * @private
    */
   get inputHidden() {
-    // When activeLabel is set, keep the input row visible so the label stays
-    // raised in the active position (classic/default layout) instead of
-    // collapsing to the centered placeholder position.
-    if (this.activeLabel) {
-      return false;
-    }
+    // In the classic/default layout, activeLabel keeps the input row visible so
+    // the label stays raised rather than collapsing to the centered placeholder
+    // position. Emphasized/snowflake always render the label inside the field,
+    // so activeLabel does not apply there. This only overrides the empty/
+    // unfocused clause — the display-value clause (combobox/datepicker) is
+    // preserved regardless.
+    const activeLabelRaisesInput = this.activeLabel && this.isClassicLayout;
 
     return (
       this.hasDisplayValueContent && !this.hasFocus && this.hasValue) ||
       (
+        !activeLabelRaisesInput &&
         (!this.value || this.value.length === 0) &&
         !this.hasFocus &&
         (!this.placeholderStr || this.placeholderStr === '')
       );
   }
 
+  /**
+   * Whether the component is rendering the classic/default layout, meaning not
+   * emphasized and not snowflake. Kept as a single source of truth so
+   * layout-scoped behavior such as activeLabel stays consistent across getters.
+   * @returns {boolean} - True for the classic/default layout.
+   * @private
+   */
+  get isClassicLayout() {
+    return !this.layout.startsWith('emphasized') && this.layout !== 'snowflake';
+  }
+
   /**
    * Determines if the input should display in a state with no focus or value indication.
    * Returns true when the input has display content without focus and has a value,
@@ -19840,7 +19853,7 @@ class AuroBibtemplate extends i$3 {
   }
 }
 
-var formkitVersion = '202608102106';
+var formkitVersion = '202608111845';
 
 var styleCss$3 = i$6`.util_displayInline{display:inline}.util_displayInlineBlock{display:inline-block}.util_displayBlock{display:block}.util_displayFlex{display:flex}.util_displayHidden{display:none}.util_displayHiddenVisually{position:absolute;overflow:hidden;clip:rect(1px, 1px, 1px, 1px);width:1px;height:1px;padding:0;border:0}:host{display:block;text-align:left}:host [auro-dropdown]{--ds-auro-dropdown-trigger-background-color: transparent}:host #inputInBib::part(wrapper){box-shadow:none}:host #inputInBib::part(accent-left){display:none}:host([layout*=classic]) [auro-input]{width:100%}:host([layout*=classic]) [auro-input]::part(helpText){display:none}:host([layout*=classic]) #slotHolder{display:none}`;
 
@@ -21646,7 +21659,17 @@ class AuroCombobox extends AuroElement {
       return;
     }
 
-    this.value = this.input.value;
+    // Skip this write during a display-value sync: that path sets the input to
+    // the selected option's LABEL, which is not its machine value. When an
+    // option's label differs from its value (and especially when several
+    // options share a value but render distinct labels — AB#1602086), writing
+    // the label back into this.value clobbers the machine value the selection
+    // listener just set (this.value = optionSelected.value), collapsing the
+    // selection. _syncingBibValue still tracks (that mirrors user-typed text
+    // from the fullscreen bib, where value should follow the input).
+    if (!this._syncingDisplayValue) {
+      this.value = this.input.value;
+    }
 
     // Ignore re-entrant input events caused by programmatic value sets.
     if (this._syncingBibValue || this._syncingDisplayValue) {
@@ -21910,33 +21933,53 @@ class AuroCombobox extends AuroElement {
       }
 
       if (this.input.value !== this.value) {
-        // Clear menu.value AND menu.optionSelected together. Clearing only
-        // menu.value leaves the previously-selected option element pinned
-        // as menu.optionSelected; a later auroMenu-selectedOption event
-        // would then write its stale .value back into combobox.value
-        // (e.g. Tab-after-Backspace re-selecting the prior option).
-        if (this.menu.value || this.menu.optionSelected) {
-          this.menu.clearSelection();
-        }
+        // A fresh user selection leaves the input showing the option's LABEL
+        // while this.value holds its machine value, so input.value !== this.value
+        // is expected whenever label ≠ value. In that case the menu's current
+        // selection is authoritative — and when several options share a value it
+        // is the ONLY thing that records WHICH same-value option the user picked
+        // (the menu tracks it by element identity via `_selectedKey`). Clearing
+        // it here drops that key; the ensuing value-only re-resolution then
+        // collapses the selection onto the first same-value option (AB#1602086).
+        // So only treat the divergence as a stale menu when the selected option
+        // does NOT match the new value.
+        const menuSelectionMatchesValue =
+          this.menu.optionSelected &&
+          // optionSelected is a single element here (scalar `.value`). A multiselect
+          // menu exposes it as an ARRAY, which has no scalar `.value` to compare, so
+          // that shape can't be a single-option match — fall through to the clear path.
+          !Array.isArray(this.menu.optionSelected) &&
+          this.menu.optionSelected.value === this.value;
+
+        if (!menuSelectionMatchesValue) {
+          // Clear menu.value AND menu.optionSelected together. Clearing only
+          // menu.value leaves the previously-selected option element pinned
+          // as menu.optionSelected; a later auroMenu-selectedOption event
+          // would then write its stale .value back into combobox.value
+          // (e.g. Tab-after-Backspace re-selecting the prior option).
+          if (this.menu.value || this.menu.optionSelected) {
+            this.menu.clearSelection();
+          }
 
-        if (!this.persistInput) {
-          this.syncInputValuesAcrossTriggerAndBib(this.value || '');
-        }
+          if (!this.persistInput) {
+            this.syncInputValuesAcrossTriggerAndBib(this.value || '');
+          }
 
-        // Programmatic value with no matching option: updateFilter will close
-        // the bib silently (see line 648 — no noMatchOption + 0 results
-        // hides). Announce so screen-reader users hear the request was
-        // dropped. Gated on `input.value !== this.value` so this never fires
-        // for user typing — that path always reconciles input.value to
-        // this.value before updated() runs.
-        if (
-          this.value &&
-          this.menu &&
-          this.menu.options &&
-          this.menu.options.length > 0 &&
-          !this.menu.options.some((opt) => opt.value === this.value)
-        ) {
-          announceToScreenReader(this._getAnnouncementRoot(), `No matching option for ${this.value}`);
+          // Programmatic value with no matching option: updateFilter will close
+          // the bib silently (see line 648 — no noMatchOption + 0 results
+          // hides). Announce so screen-reader users hear the request was
+          // dropped. Gated on `input.value !== this.value` so this never fires
+          // for user typing — that path always reconciles input.value to
+          // this.value before updated() runs.
+          if (
+            this.value &&
+            this.menu &&
+            this.menu.options &&
+            this.menu.options.length > 0 &&
+            !this.menu.options.some((opt) => opt.value === this.value)
+          ) {
+            announceToScreenReader(this._getAnnouncementRoot(), `No matching option for ${this.value}`);
+          }
         }
       }
 
@@ -22273,6 +22316,116 @@ function isSelectableByValue(option) {
          !option.hasAttribute('static');
 }
 
+/* eslint-disable no-underscore-dangle */
+/**
+ * Resolves the single selected option for a given `value`, preferring the
+ * option tracked by `selectedKey` (a user-initiated selection) over a
+ * first-by-value match. When multiple options share the same `value`, matching
+ * by `value` alone cannot distinguish which one the user picked; the key
+ * disambiguates it.
+ *
+ * The key is trusted only when it still resolves to an option whose `value`
+ * matches the requested `value`. If the key is stale (option removed) or the
+ * value was changed programmatically, resolution falls back to value matching —
+ * preserving backward-compatible behavior for preselection and `selectByValue`.
+ * @private
+ * @param {Array<HTMLElement>} items - The menu's flat option list.
+ * @param {string} value - The value to resolve.
+ * @param {string|undefined} selectedKey - The `_optionKey` of the user-selected option, if any.
+ * @returns {HTMLElement|undefined} The resolved option, or undefined when none match.
+ */
+function resolveSelectedOption(items, value, selectedKey) {
+  if (!items) {
+    return undefined;
+  }
+
+  if (selectedKey !== undefined) {
+    const keyed = items.find((item) => item._optionKey === selectedKey);
+    if (keyed && isSelectableByValue(keyed) && keyed.value === value) {
+      return keyed;
+    }
+    // Key exists but the option is gone or its value no longer matches — fall
+    // through to value-based matching.
+  }
+
+  return items.find((item) => isSelectableByValue(item) && item.value === value);
+}
+
+/**
+ * Resolves the selected options for a multi-select `value` array, preferring
+ * options tracked by `selectedKeys` (user-initiated selections) and falling
+ * back to value matching for any values not resolved by key. The result is
+ * always sorted into DOM order regardless of selection sequence.
+ * @private
+ * @param {Array<HTMLElement>} items - The menu's flat option list.
+ * @param {Array<string>} valueArray - The selected values.
+ * @param {Array<string>|undefined} selectedKeys - The `_optionKey`s of the user-selected options, if any.
+ * @returns {Array<HTMLElement>} The resolved options in DOM order.
+ */
+function resolveSelectedOptions(items, valueArray, selectedKeys) {
+  if (!items) {
+    return [];
+  }
+
+  const resolved = [];
+  // Mirror `resolved` as a Set for O(1) membership checks below, matching the
+  // indexMap optimization used for the sort rather than scanning `resolved`
+  // on every candidate.
+  const resolvedSet = new Set();
+
+  // Track how many of each value are still available to resolve. A value that
+  // appears N times in `valueArray` may be satisfied at most N times total across
+  // the key pass and the value fallback below — matching by count, not presence,
+  // on BOTH passes. This stops a duplicate value from being over-resolved: e.g.
+  // two keyed options that both carry `SEA` cannot both match a single requested
+  // `SEA` (which happens when `value` is set directly without clearing
+  // `_selectedKey`, so more keys survive than the value set now asks for).
+  const remaining = new Map();
+  valueArray.forEach((val) => remaining.set(val, (remaining.get(val) || 0) + 1));
+
+  // Resolve by key first: trust a key only when its option is still selectable
+  // and there is still an unmatched occurrence of its value in the request set.
+  if (Array.isArray(selectedKeys)) {
+    selectedKeys.forEach((key) => {
+      const keyed = items.find((item) => item._optionKey === key);
+      if (keyed && isSelectableByValue(keyed) && (remaining.get(keyed.value) || 0) > 0 && !resolvedSet.has(keyed)) {
+        resolved.push(keyed);
+        resolvedSet.add(keyed);
+        remaining.set(keyed.value, remaining.get(keyed.value) - 1);
+      }
+    });
+  }
+
+  // Fall back to value matching for the occurrences not resolved by key. Iterate
+  // the leftover per-value counts so a value that appears twice but was only
+  // resolved once by key still matches its remaining occurrence(s).
+  remaining.forEach((count, val) => {
+    for (let occurrence = 0; occurrence < count; occurrence += 1) {
+      const option = items.find((item) => isSelectableByValue(item) && item.value === val && !resolvedSet.has(item));
+      if (option) {
+        resolved.push(option);
+        resolvedSet.add(option);
+      }
+    }
+  });
+
+  // Always return in DOM order so display is consistent regardless of the order
+  // keys/values were selected. Every resolved option came from `items`, so an
+  // O(1) index lookup mirrors `_sortSelectedByDomOrder` and avoids the O(n)
+  // `items.indexOf` per comparison for large combobox option sets. Any element
+  // not in `items` (a stale snapshot from a future caller) sorts to the END via
+  // `?? items.length`, matching `_sortSelectedByDomOrder` and avoiding NaN
+  // comparisons.
+  const indexMap = new Map(items.map((item, index) => [
+    item,
+    index
+  ]));
+  resolved.sort((optionA, optionB) => (indexMap.get(optionA) ?? items.length) - (indexMap.get(optionB) ?? items.length));
+
+  return resolved;
+}
+/* eslint-enable no-underscore-dangle */
+
 /**
  * Helper method to dispatch custom events.
  * @param {HTMLElement} element - Element to dispatch event from.
@@ -22298,6 +22451,14 @@ function dispatchMenuEvent(element, eventName, detail = null) {
 // See LICENSE in the project root for license information.
 
 
+/**
+ * Monotonically increasing counter used to give each menu instance a unique
+ * `_menuInstanceId` prefix. Auto-generating the id (rather than using a random
+ * string) keeps option keys deterministic and collision-free across menus.
+ * @private
+ */
+let menuInstanceIdCounter = 0;
+
 
 /**
  * The `auro-menu` element provides users a way to select from a list of options.
@@ -22369,9 +22530,8 @@ class AuroMenu extends AuroElement {
 
     // Instance properties (non-reactive)
 
-    /**
-     * @private
-     */
+    menuInstanceIdCounter += 1;
+
     Object.assign(this, {
       // Root-level menu (true) or a nested submenu (false)
       rootMenu: true,
@@ -22381,6 +22541,21 @@ class AuroMenu extends AuroElement {
       nestingSpacer: '<span class="nestingSpacer"></span>',
       // Loading indicator for slot elements
       loadingSlots: null,
+      // Unique id for this menu instance; prefixes every auto-generated option
+      // key so keys never collide across menus in the same document.
+      _menuInstanceId: `menu-${menuInstanceIdCounter}`,
+      // Monotonically increasing counter for option key generation. Never
+      // resets, so a key is never reused within this instance's lifetime.
+      _optionKeyCounter: 0,
+      // Key(s) of the option(s) the user has actively selected. A single string
+      // in single-select, an array in multi-select, undefined when nothing is
+      // user-selected. Used to disambiguate options that share a `value`.
+      _selectedKey: undefined,
+      // True only for the one updated() cycle following a user selection, so
+      // reconciliation trusts `_selectedKey`. A `value` change from a consumer's
+      // direct property assignment leaves this false, dropping the stale key so
+      // reconciliation falls back to first-by-value (see updated()).
+      _valueChangeFromSelection: false,
     });
   }
 
@@ -22600,6 +22775,13 @@ class AuroMenu extends AuroElement {
       return;
     }
 
+    // A programmatic value set carries no positional intent, so drop any
+    // `_selectedKey` left over from a prior user click. This makes reconciliation
+    // in updated() fall back to first-by-value (single) / value-in-DOM-order
+    // (multi), matching the documented contract for programmatic selection even
+    // when a stale key would still resolve to a duplicate-value option.
+    this._selectedKey = undefined;
+
     // `value` is a String property; stringify arrays so attribute reflection and `formattedValue` parsing stay correct.
     this.value = Array.isArray(value) ? JSON.stringify(value) : value;
   }
@@ -22647,6 +22829,17 @@ class AuroMenu extends AuroElement {
   updated(changedProperties) {
     super.updated(changedProperties);
 
+    // Consume the selection-driven flag for THIS cycle up front. Clearing it
+    // unconditionally — not only inside the `value` branch below — prevents it
+    // from lingering `true` when a selection produces a serialized `value`
+    // byte-identical to the current one, in which case Lit schedules no
+    // `value`-change cycle to consume it. A lingering flag would misclassify a
+    // later consumer's programmatic `value` set as selection-driven and keep a
+    // stale `_selectedKey`. The reconcile path below re-sets the instance flag
+    // after this point, so its intentional cross-cycle hand-off still works.
+    const valueChangeFromSelection = this._valueChangeFromSelection;
+    this._valueChangeFromSelection = false;
+
     // Single source of truth for 'auroMenu-selectedOption'. Selection handlers
     // mutate optionSelected and let Lit's update cycle dispatch here; the prior
     // .value comparison missed multi-select array changes and combined with the
@@ -22670,6 +22863,17 @@ class AuroMenu extends AuroElement {
         this.initItems();
       }
 
+      // Distinguish a selection-driven `value` change (a user click, which set
+      // the flag in handleSelectState / _sortSelectedByDomOrder) from a
+      // programmatic assignment by a consumer. A programmatic set carries no
+      // positional intent, so drop any leftover `_selectedKey` and let
+      // reconciliation fall back to first-by-value (single) / value-in-DOM-order
+      // (multi) — the same contract selectByValue() guarantees, even when a
+      // stale key would otherwise still resolve to a duplicate-value option.
+      if (!valueChangeFromSelection) {
+        this._selectedKey = undefined;
+      }
+
       // Set when reconciliation reassigns `value` below. That reassignment schedules a
       // second updated() cycle, so the `event`-attribute dispatch is deferred to that
       // cycle to avoid firing option custom events twice on the same selection.
@@ -22687,19 +22891,55 @@ class AuroMenu extends AuroElement {
           // Defensive default: `formattedValue` can be undefined for unexpected value types,
           // and calling `.includes` on undefined would throw during reconciliation.
           const valueArray = this.formattedValue || [];
-          const matchingOptions = this.items ? this.items.filter((item) => isSelectableByValue(item) && valueArray.includes(item.value)) : [];
+          // Resolve by key first (the user's exact picks), then fall back to
+          // value matching for any values not resolved by key — so pre-selection
+          // and programmatic value sets keep working. Result is DOM-ordered.
+          const matchingOptions = resolveSelectedOptions(this.items, valueArray, this._selectedKey);
           newSelected = matchingOptions.length > 0 ? matchingOptions : undefined;
 
-          // Reconcile `value` with the selectable set. Drop only entries whose option is
-          // loaded but non-selectable (disabled/static) — leaving them would desync `value`
-          // from `optionSelected`, and the toggle handlers rebuild `value` from `formattedValue`,
-          // so the rejected entry would resurface on the next select/deselect. Entries with no
-          // matching item yet are preserved so async preselection still works once options render.
-          const rejectedValues = this.items
-            ? this.items.filter((item) => !isSelectableByValue(item) && valueArray.includes(item.value)).map((item) => item.value)
-            : [];
-          if (rejectedValues.length > 0) {
-            const reconciled = valueArray.filter((val) => !rejectedValues.includes(val));
+          // Reconcile `value` with the selectable set. An occurrence is dropped
+          // only when it is loaded but no selectable option can satisfy it —
+          // every loaded item sharing that value is non-selectable, or the value
+          // recurs more often than it has selectable options (a duplicate value
+          // whose extra siblings are disabled/static). This is count-based, not
+          // presence-based, so an enabled option is kept even when a disabled
+          // sibling shares its value — mirroring how `resolveSelectedOptions`
+          // resolves the same set. Entries with no matching item yet are
+          // preserved so async preselection still works, and the toggle handlers
+          // rebuild `value` from `formattedValue`, so a rejected entry cannot
+          // resurface on the next select/deselect.
+          const selectableByValue = new Map();
+          const loadedValues = new Set();
+          if (this.items) {
+            this.items.forEach((item) => {
+              loadedValues.add(item.value);
+              if (isSelectableByValue(item)) {
+                selectableByValue.set(item.value, (selectableByValue.get(item.value) || 0) + 1);
+              }
+            });
+          }
+
+          const reconciled = valueArray.filter((val) => {
+            // Not loaded yet (async preselection) — keep for a later cycle.
+            if (!loadedValues.has(val)) {
+              return true;
+            }
+            // Consume one selectable option per occurrence; drop once exhausted.
+            const remaining = selectableByValue.get(val) || 0;
+            if (remaining > 0) {
+              selectableByValue.set(val, remaining - 1);
+              return true;
+            }
+            return false;
+          });
+
+          if (reconciled.length !== valueArray.length) {
+            // This is an internal correction, not a consumer's programmatic set,
+            // so preserve the selection-driven flag through the re-entrant
+            // updated() cycle it schedules. Otherwise that cycle would treat the
+            // reassignment as programmatic and drop `_selectedKey` mid-cascade,
+            // flipping resolution and looping.
+            this._valueChangeFromSelection = true;
             this.value = serializeMultiSelectValue(reconciled);
             valueReconciled = true;
           }
@@ -22711,7 +22951,11 @@ class AuroMenu extends AuroElement {
           // `hidden` is intentionally NOT excluded: the combobox toggles
           // `hidden` as its type-ahead filter, so a filtered-out option is
           // still a valid programmatic selection.
-          const matchingOption = this.items ? this.items.find((item) => isSelectableByValue(item) && item.value === this.value) : undefined;
+          // Prefer the option the user actually selected (tracked by
+          // `_selectedKey`) so a click on the second of two options sharing a
+          // `value` resolves back to that exact element instead of the first
+          // value match. Falls back to first-by-value for programmatic sets.
+          const matchingOption = resolveSelectedOption(this.items, this.value, this._selectedKey);
 
           if (matchingOption) {
             newSelected = matchingOption;
@@ -22939,6 +23183,14 @@ class AuroMenu extends AuroElement {
       }
     });
 
+    // Assign private keys once items are populated. Only the root menu assigns
+    // keys: its `items` is a deep query that already includes nested submenu
+    // options, so a single pass keys the entire tree. Nested menus skip this
+    // and inherit keys from the root.
+    if (this.rootMenu) {
+      this._assignOptionKeys();
+    }
+
     if (this.noCheckmark) {
       this.updateItemsState(new Map([
         [
@@ -22955,6 +23207,31 @@ class AuroMenu extends AuroElement {
     }));
   }
 
+  /**
+   * Assigns a private, auto-generated unique key (`_optionKey`) to each menu
+   * option that does not already have one. Keys are internal state on the
+   * element instance — never reflected as an attribute or exposed publicly —
+   * and let selection tracking distinguish options that share the same `value`.
+   *
+   * The `_optionKey === undefined` guard makes this idempotent: options keep the
+   * key they were first assigned across re-renders and slot changes, and if a
+   * nested menu's lifecycle runs a pass before the root, options simply wait for
+   * the root to key them (or keep whatever key they already hold).
+   * @private
+   */
+  _assignOptionKeys() {
+    if (!this.items) {
+      return;
+    }
+
+    this.items.forEach((option) => {
+      if (option._optionKey === undefined) {
+        this._optionKeyCounter += 1;
+        option._optionKey = `${this._menuInstanceId}-${this._optionKeyCounter}`;
+      }
+    });
+  }
+
   // Logic Methods
 
   /**
@@ -22964,24 +23241,28 @@ class AuroMenu extends AuroElement {
    */
   handleSelectState(option) {
     if (this.multiSelect) {
-      const currentValue = this.formattedValue || [];
       const currentSelected = this.optionSelected || [];
 
-      if (!currentValue.includes(option.value)) {
-        this.value = serializeMultiSelectValue([
-          ...currentValue,
-          option.value
-        ]);
-      }
       if (!currentSelected.includes(option)) {
         this.optionSelected = [
           ...currentSelected,
           option
         ];
       }
+
+      // Re-sort by DOM order and rebuild `_selectedKey`/`value` from the
+      // selected set so display order stays consistent with the menu, not with
+      // click order.
+      this._sortSelectedByDomOrder();
     } else {
       this.value = option.value;
       this.optionSelected = option;
+      // Track the specific option the user selected so the value→option
+      // reconciliation in updated() resolves back to this exact element even
+      // when another option shares the same `value`.
+      this._selectedKey = option._optionKey;
+      // Mark this `value` change as selection-driven so updated() trusts the key.
+      this._valueChangeFromSelection = true;
     }
 
     this._index = this.items.indexOf(option);
@@ -22994,18 +23275,22 @@ class AuroMenu extends AuroElement {
    */
   handleDeselectState(option) {
     if (this.multiSelect) {
-      // Remove this option from array; an empty result collapses `value` to undefined.
-      const newFormattedValue = (this.formattedValue || []).filter((val) => val !== option.value);
-      this.value = serializeMultiSelectValue(newFormattedValue);
-
-      this.optionSelected = this.optionSelected.filter((val) => val !== option);
+      // Remove this exact element from the selection (identity, not value — two
+      // options can share a `value`), then rebuild `value`/`_selectedKey` from
+      // the remaining set in DOM order. An empty result collapses to undefined.
+      this.optionSelected = this.optionSelected.filter((selected) => selected !== option);
       if (this.optionSelected.length === 0) {
         this.optionSelected = undefined;
+        this._selectedKey = undefined;
+        this.value = undefined;
+      } else {
+        this._sortSelectedByDomOrder();
       }
     } else {
       // For single-select: Back to undefined when deselected
       this.value = undefined;
       this.optionSelected = undefined;
+      this._selectedKey = undefined;
     }
 
     // Update the index tracking
@@ -23029,9 +23314,46 @@ class AuroMenu extends AuroElement {
   clearSelection() {
     this.optionSelected = undefined;
     this.value = undefined;
+    this._selectedKey = undefined;
     this._index = -1;
   }
 
+  /**
+   * Re-sorts the multi-select selection into DOM order and rebuilds the derived
+   * `_selectedKey` and `value` from `optionSelected`. Selection is always stored
+   * and serialized in the order options appear in the menu, never in click
+   * order — so selecting C then A yields `[A, C]`.
+   * @private
+   */
+  _sortSelectedByDomOrder() {
+    if (!this.multiSelect || !Array.isArray(this.optionSelected) || !this.items) {
+      return;
+    }
+
+    const indexMap = new Map(this.items.map((item, index) => [
+      item,
+      index
+    ]));
+
+    // Sorting in place mutates `optionSelected` without a new array reference,
+    // which Lit's `===` change-detection cannot see on its own — but that is
+    // intentional and safe: both callers (handleSelectState / handleDeselectState)
+    // assign a fresh `optionSelected` array immediately before calling, so Lit
+    // already has a changed reference to react to, and the `value` write below
+    // schedules the updated() cycle that re-derives `optionSelected` in DOM order
+    // via resolveSelectedOptions. Do not "fix" this into a new-array assignment.
+    //
+    // Sort any element no longer in `items` (a stale selection left over from a
+    // dynamic rebuild that the consumer has not cleared) to the END rather than
+    // the front, so it never displaces a live option to the head of the
+    // serialized order. Value reconciliation drops it on the next updated() cycle.
+    this.optionSelected.sort((optionA, optionB) => (indexMap.get(optionA) ?? this.items.length) - (indexMap.get(optionB) ?? this.items.length));
+    this._selectedKey = this.optionSelected.map((option) => option._optionKey);
+    this.value = serializeMultiSelectValue(this.optionSelected.map((option) => option.value));
+    // Mark this `value` change as selection-driven so updated() trusts the keys.
+    this._valueChangeFromSelection = true;
+  }
+
   /**
    * Resets the menu to its initial state.
    * This is the only way to return value to undefined.
@@ -23041,6 +23363,7 @@ class AuroMenu extends AuroElement {
     // Reset to undefined - initial state
     this.value = undefined;
     this.optionSelected = undefined;
+    this._selectedKey = undefined;
     this._index = -1;
 
     // Clear active option state so a follow-up open/navigation starts fresh
@@ -23102,6 +23425,21 @@ class AuroMenu extends AuroElement {
       this.initItems();
     }
 
+    // Recover `_index` from the highlighted option when it has been reset to -1.
+    // The updated() reconciliation resets `_index = -1` whenever the value
+    // collapses to undefined while `optionActive` still points at the highlighted
+    // option — e.g. deselecting the last remaining option in multi-select, or a
+    // programmatic clearSelection() in single-select while keyboard focus is on an
+    // option. Without this, reading `items[-1]` returns undefined and the re-select
+    // no-ops until the highlight is moved away and back. Mirrors auro-combobox's
+    // reconcileMenuIndex.
+    if (this._index < 0 && this.optionActive && this.items) {
+      const activeIndex = this.items.indexOf(this.optionActive);
+      if (activeIndex >= 0) {
+        this._index = activeIndex;
+      }
+    }
+
     // Get currently selected menu option based on index
     const option = this.items ? this.items[this._index] : undefined;