@aurodesignsystem-dev/auro-formkit 0.0.0-pr1492.5 → 0.0.0-pr1493.0

package/components/combobox/dist/index.js

@@ -555,7 +555,7 @@ let AuroFormValidation$1 = class AuroFormValidation {
       } else if (this.runtimeUtils.elementMatch(elem, 'auro-input') && elem.errorMessage === '') {
         const input = elem.renderRoot.querySelector('input');
 
-        if (input.validationMessage.length > 0) {
+        if (input && input.validationMessage.length > 0) {
           elem.errorMessage = input.validationMessage;
         }
       } else if (this.runtimeUtils.elementMatch(elem, 'auro-combobox') && elem.errorMessage === '') {
@@ -797,6 +797,21 @@ function isClearBtnFocused(ctx, clearBtn = getClearBtn(ctx)) {
   return isFocused;
 }
 
+/**
+ * Reconcile the menu `_index` from `optionActive` so subsequent `makeSelection` calls find the correct option after async clearSelection has reset it.
+ * @param {Object} menu - The menu component.
+ */
+function reconcileMenuIndex(menu) {
+  // eslint-disable-next-line no-underscore-dangle
+  if (menu._index < 0 && menu.optionActive && menu.items) {
+    const idx = menu.items.indexOf(menu.optionActive);
+    if (idx >= 0) {
+      // eslint-disable-next-line no-underscore-dangle
+      menu._index = idx;
+    }
+  }
+}
+
 const comboboxKeyboardStrategy = {
   ArrowDown(component, evt, ctx) {
     // If the clear button has focus, let the browser handle ArrowDown normally.
@@ -860,6 +875,7 @@ const comboboxKeyboardStrategy = {
       // block the browser's built-in "Enter activates focused button" behavior.
       evt.stopPropagation();
     } else if (ctx.isExpanded && component.menu.optionActive) {
+      reconcileMenuIndex(component.menu);
       component.menu.makeSelection();
 
       if (ctx.isModal) {
@@ -907,6 +923,7 @@ const comboboxKeyboardStrategy = {
       // When the clear button is focused, Tab events do not bubble out of
       // its shadow DOM, so this handler only fires when the clear button
       // is NOT focused. In that case, select the active option and close.
+      reconcileMenuIndex(component.menu);
       component.menu.makeSelection();
       component.hideBib();
 
@@ -4158,7 +4175,7 @@ function applyKeyboardStrategy(component, strategy, options = {}) {
   });
 }
 
-var styleCss$2$1 = css`:host{position:fixed;z-index:var(--depth-tooltip, 400);display:none;isolation:isolate}:host dialog{width:auto;max-width:none;height:auto;max-height:none;padding:0;border:none;margin:0;outline:none;transform:translateZ(0)}:host dialog::backdrop{background:transparent}:host(:not([isfullscreen])) dialog{position:relative;inset:unset}:host(:not([isfullscreen])) .container.shape-box{border-radius:unset}:host(:not([isfullscreen])) .container[class*=shape-pill],:host(:not([isfullscreen])) .container[class*=shape-snowflake]{border-radius:30px}:host(:not([isfullscreen])) .container[class*=shape-rounded]{border-radius:16px}:host(:not([matchWidth])) .container{min-width:fit-content}:host([isfullscreen]){position:fixed;top:0;left:0}:host([isfullscreen]) .container{width:100dvw;max-width:none;height:100dvh;max-height:none;border-radius:unset;margin-top:0;box-shadow:unset;overscroll-behavior:contain}:host([isfullscreen]) .container::backdrop{background:var(--ds-color-background-primary, #fff)}:host(:popover-open){position:fixed;overflow:visible;padding:0;border:none;margin:0;background:transparent;inset:unset;outline:none}:host([data-show]){display:flex}:host([common]:not([isfullscreen])) .container,:host([rounded]:not([isfullscreen])) .container{border-radius:var(--ds-border-radius, 0.375rem)}:host([common][isfullscreen]) .container,:host([rounded][isfullscreen]) .container{border-radius:unset;box-shadow:unset}.container{display:inline-block;overflow:auto;box-sizing:border-box;border-radius:var(--ds-border-radius, 0.375rem);margin:var(--ds-size-50, 0.25rem) 0}.util_displayHiddenVisually{position:absolute;overflow:hidden;width:1px;height:1px;padding:0;border:0;margin:-1px;clip-path:inset(50%);white-space:nowrap}`;
+var styleCss$2$1 = css`:host{position:fixed;z-index:var(--depth-tooltip, 400);display:none;isolation:isolate}:host dialog{width:auto;max-width:none;height:auto;max-height:none;padding:0;border:none;margin:0;outline:none;transform:translateZ(0)}:host dialog::backdrop{background:transparent}:host(:not([isfullscreen])) dialog{position:relative;inset:unset}:host(:not([isfullscreen])) .container.shape-box{border-radius:unset}:host(:not([isfullscreen])) .container[class*=shape-pill],:host(:not([isfullscreen])) .container[class*=shape-snowflake]{border-radius:30px}:host(:not([isfullscreen])) .container[class*=shape-rounded]{border-radius:16px}:host([desktopmodal]:popover-open)::backdrop{background:transparent}:host(:not([matchWidth])) .container{min-width:fit-content}:host([isfullscreen]){position:fixed;top:0;left:0}:host([isfullscreen]) .container{width:100dvw;max-width:none;height:100dvh;max-height:none;border-radius:unset;margin-top:0;box-shadow:unset;overscroll-behavior:contain}:host([isfullscreen]) .container::backdrop{background:var(--ds-color-background-primary, #fff)}:host(:popover-open){position:fixed;overflow:visible;padding:0;border:none;margin:0;background:transparent;inset:unset;outline:none}:host([data-show]){display:flex}:host([common]:not([isfullscreen])) .container,:host([rounded]:not([isfullscreen])) .container{border-radius:var(--ds-border-radius, 0.375rem)}:host([common][isfullscreen]) .container,:host([rounded][isfullscreen]) .container{border-radius:unset;box-shadow:unset}.container{display:inline-block;overflow:auto;box-sizing:border-box;border-radius:var(--ds-border-radius, 0.375rem);margin:var(--ds-size-50, 0.25rem) 0}.util_displayHiddenVisually{position:absolute;overflow:hidden;width:1px;height:1px;padding:0;border:0;margin:-1px;clip-path:inset(50%);white-space:nowrap}`;
 
 var colorCss$2$1 = css`.container{background-color:var(--ds-auro-dropdownbib-container-color);box-shadow:var(--ds-auro-dropdownbib-boxshadow-color);color:var(--ds-auro-dropdownbib-text-color)}`;
 
@@ -4789,7 +4806,7 @@ let AuroHelpText$2 = class AuroHelpText extends LitElement {
   }
 };
 
-var formkitVersion$2 = '202606031942';
+var formkitVersion$2 = '202606181613';
 
 let AuroElement$2 = class AuroElement extends LitElement {
   static get properties() {
@@ -4969,6 +4986,7 @@ class AuroDropdown extends AuroElement$2 {
   _intializeDefaults() {
     this.appearance = 'default';
     this.chevron = false;
+    this.desktopModal = false;
     this.disabled = false;
     this.disableKeyboardHandling = false;
     this.error = false;
@@ -5149,6 +5167,14 @@ class AuroDropdown extends AuroElement$2 {
         reflect: true
       },
 
+      /**
+       * If declared, the dropdown will behave as a modal dialog when in a desktop viewport size.
+       */
+      desktopModal: {
+        type: Boolean,
+        reflect: true
+      },
+
       /**
        * If declared, the dropdown will only show by calling the API .show() public method.
        */
@@ -5436,6 +5462,15 @@ class AuroDropdown extends AuroElement$2 {
 
   disconnectedCallback() {
     super.disconnectedCallback();
+    this._clearPageInert();
+    if (this._bibTabHandler) {
+      this.removeEventListener('keydown', this._bibTabHandler);
+      this._bibTabHandler = undefined;
+    }
+    if (this.focusTrap) {
+      this.focusTrap.disconnect();
+      this.focusTrap = undefined;
+    }
     if (this.floater) {
       this.floater.hideBib('disconnect');
       this.floater.disconnect();
@@ -5463,19 +5498,45 @@ class AuroDropdown extends AuroElement$2 {
       if (this.isPopoverVisible) {
         // Fullscreen: use showModal() for native accessibility (inert outside, focus trap)
         // Desktop: use show() for Floating UI positioning + FocusTrap for focus management
-        const useModal = this.isBibFullscreen;
-        this.bibElement.value.open(useModal);
+        this.bibElement.value.open(this.isBibFullscreen);
+        this.updateFocusTrap();
+
+        // Desktop modal: make siblings inert so content outside is not interactive
+        if (this.desktopModal && !this.isBibFullscreen) {
+          this._setPageInert();
+        }
       } else {
         this.bibElement.value.close();
+        this._clearPageInert();
       }
     }
 
     // When fullscreen strategy changes while open, re-open dialog with correct mode
     // (e.g. resizing from desktop → mobile while dropdown is open)
     if (changedProperties.has('isBibFullscreen') && this.isPopoverVisible && this.bibElement.value) {
-      const useModal = this.isBibFullscreen;
       this.bibElement.value.close();
-      this.bibElement.value.open(useModal);
+      this.bibElement.value.open(this.isBibFullscreen);
+
+      // Re-initialize focus management for the new strategy
+      this.updateFocusTrap();
+
+      // Toggle inert: desktop modal needs it, fullscreen showModal() handles it natively
+      if (this.desktopModal && !this.isBibFullscreen) {
+        this._setPageInert();
+      } else {
+        this._clearPageInert();
+      }
+    }
+
+    // Handle desktopModal toggled while the dropdown is already open.
+    // Re-initialize focus trapping and page inert state to match the new mode.
+    if (changedProperties.has('desktopModal') && this.isPopoverVisible && !this.isBibFullscreen) {
+      this.updateFocusTrap();
+      if (this.desktopModal) {
+        this._setPageInert();
+      } else {
+        this._clearPageInert();
+      }
     }
   }
 
@@ -5485,8 +5546,14 @@ class AuroDropdown extends AuroElement$2 {
    * @param {CustomEvent} event - The custom event that contains the dropdown toggle information.
    */
   handleDropdownToggle(event) {
-    this.updateFocusTrap();
     this.isPopoverVisible = event.detail.expanded;
+
+    // Tear down FocusTrap when closing. Creation happens in updated()
+    // after the dialog is open so getFocusableElements can find content.
+    if (!this.isPopoverVisible) {
+      this.updateFocusTrap();
+    }
+
     const eventType = event.detail.eventType || "unknown";
     if (!this.isPopoverVisible && this.hasFocus && eventType === "keydown") {
       this.trigger.focus();
@@ -5585,19 +5652,220 @@ class AuroDropdown extends AuroElement$2 {
    * @private
    */
   updateFocusTrap() {
+    // Always clean up existing handlers/traps before setting up new ones
+    // to prevent duplicate listeners on repeated calls.
+    if (this._bibTabHandler) {
+      this.removeEventListener('keydown', this._bibTabHandler);
+      this._bibTabHandler = undefined;
+    }
+
+    if (this.focusTrap) {
+      this.focusTrap.disconnect();
+      this.focusTrap = undefined;
+    }
+
+    // Restore the user-set noHideOnThisFocusLoss value, if we overrode it.
+    if (this._noHideOverridden) {
+      this.noHideOnThisFocusLoss = this._priorNoHide;
+      this._noHideOverridden = false;
+      this._priorNoHide = undefined;
+    }
+
     if (this.isPopoverVisible) {
       if (!this.isBibFullscreen) {
-        // Desktop: show() doesn't trap focus, so use FocusTrap
-        this.focusTrap = new FocusTrap(this.bibContent);
-        this.focusTrap.focusFirstElement();
+        if (this.desktopModal) {
+          // The floater's focus-loss check uses :focus-within, which does not
+          // match the host when focus is on a slotted element projected through
+          // multiple shadow roots. Without this override, focusing a button
+          // inside the bib would be misread as focus leaving the dropdown and
+          // close the bib immediately. desktopModal traps focus inside the
+          // bib and inerts siblings, so suppressing focus-loss dismissal here
+          // is safe — Escape and outside-click still close the bib.
+          this._priorNoHide = this.noHideOnThisFocusLoss;
+          this._noHideOverridden = true;
+          this.noHideOnThisFocusLoss = true;
+
+          // Desktop modal: trap focus only within the bib content.
+          // Can't use FocusTrap on the bib element because keydown events
+          // from slotted content bubble through the dropdown host (light DOM),
+          // not through the bib (shadow projection target). Using FocusTrap
+          // on the dropdown would include the trigger in the tab cycle.
+          // Instead, listen for Tab on the dropdown and manually wrap focus
+          // within the bib's focusable elements.
+          this._bibTabHandler = (event) => {
+            if (event.key !== 'Tab') {
+              return;
+            }
+
+            // Collect focusable elements from the bib content.
+            const focusables = getFocusableElements(this.bibContent);
+
+            // Fallback: try from slotted content directly
+            if (!focusables.length) {
+              const slot = this.shadowRoot.querySelector('.slotContent slot');
+              const assignedNodes = slot.assignedNodes({ flatten: true });
+
+              for (const node of assignedNodes) {
+                if (node.nodeType === Node.ELEMENT_NODE) {
+                  focusables.push(...getFocusableElements(node));
+                }
+              }
+            }
+
+            if (!focusables.length) {
+              return;
+            }
+
+            event.preventDefault();
+
+            const direction = event.shiftKey ? -1 : 1; // eslint-disable-line no-magic-numbers
+
+            // Walk the active element chain through shadow roots
+            const actives = this._getActiveElements();
+
+            let idx = focusables.findIndex((el) => actives.includes(el));
+
+            if (idx === -1) { // eslint-disable-line no-magic-numbers
+              // Focus is not on a known element — move to first/last
+              idx = direction === 1 ? -1 : focusables.length; // eslint-disable-line no-magic-numbers
+            }
+
+            // Try each element in order, skipping any that can't receive focus
+            // (e.g. hidden elements, elements in collapsed sections)
+            for (let index = 0; index < focusables.length; index++) { // eslint-disable-line no-plusplus
+              let nextIdx = idx + direction;
+
+              // Wrap around
+              if (nextIdx < 0) {
+                nextIdx = focusables.length - 1;
+              } else if (nextIdx >= focusables.length) {
+                nextIdx = 0;
+              }
+
+              focusables[nextIdx].focus();
+
+              // Verify focus actually moved to the target
+              const newActives = this._getActiveElements();
+
+              if (newActives.includes(focusables[nextIdx])) {
+                return;
+              }
+
+              // Focus didn't stick — skip this element and try the next
+              idx = nextIdx;
+            }
+          };
+          this.addEventListener('keydown', this._bibTabHandler);
+
+          // Move initial focus into the bib content, matching FocusTrap behavior
+          requestAnimationFrame(() => {
+            const focusables = getFocusableElements(this.bibContent);
+            if (focusables.length) {
+              focusables[0].focus();
+            }
+          });
+        } else {
+          // Normal desktop: use FocusTrap on the bib element.
+          // Defer focusFirstElement to the next frame because the popover
+          // is positioned asynchronously by Floating UI — calling focus()
+          // synchronously here would target elements with zero dimensions
+          // and the focus call would be silently ignored.
+          this.focusTrap = new FocusTrap(this.bibContent);
+          requestAnimationFrame(() => {
+            if (this.focusTrap) {
+              this.focusTrap.focusFirstElement();
+            }
+          });
+        }
       }
       // Fullscreen: showModal() provides native focus trapping
+    }
+  }
+
+  /**
+   * Returns the chain of active (focused) elements through shadow roots.
+   * @private
+   * @returns {Array<HTMLElement>}
+   */
+  _getActiveElements() {
+    let { activeElement } = document;
+    const actives = [activeElement];
+
+    while (activeElement?.shadowRoot?.activeElement) {
+      activeElement = activeElement.shadowRoot.activeElement;
+      actives.push(activeElement);
+    }
+
+    return actives;
+  }
+
+  /**
+   * Sets `inert` on sibling elements of the dropdown's top-level host
+   * so that content outside the dropdown is not interactive while the modal is open.
+   * Walks up through shadow DOM boundaries to find the outermost host element
+   * in the light DOM, then sets `inert` on siblings at each ancestor level
+   * to ensure all page content outside the host subtree is inert.
+   * @private
+   */
+  _setPageInert() {
+    if (this._inertSiblings) {
       return;
     }
 
-    if (this.focusTrap) {
-      this.focusTrap.disconnect();
-      this.focusTrap = undefined;
+    this._inertSiblings = [];
+
+    // Walk up through shadow DOM boundaries to find the topmost host
+    // element in the light DOM. For example, if this dropdown is inside
+    // auro-datepicker's shadow DOM, we walk up to the datepicker element
+    // so we set inert on its siblings — not on the datepicker itself.
+    let host = this;
+    while (host.getRootNode() instanceof ShadowRoot) {
+      host = host.getRootNode().host;
+    }
+
+    // Walk up the ancestor chain, inerting siblings at each level
+    // to ensure the entire page outside the host subtree is inert.
+    // Uses a reference counter (data-auro-inert-count) so multiple
+    // simultaneous modal dropdowns share inert state safely.
+    let current = host;
+    while (current.parentElement) {
+      const parent = current.parentElement;
+      for (const sibling of parent.children) {
+        if (sibling !== current) {
+          const count = parseInt(sibling.dataset.auroInertCount || '0', 10);
+          if (count === 0) {
+            sibling.dataset.auroInertWas = sibling.inert ? 'true' : 'false';
+          }
+          sibling.dataset.auroInertCount = String(count + 1);
+          sibling.inert = true;
+          this._inertSiblings.push(sibling);
+        }
+      }
+      current = parent;
+    }
+  }
+
+  /**
+   * Restores `inert` state on siblings that were tracked by `_setPageInert`.
+   * Uses reference counting so inert is only cleared when the last modal
+   * dropdown releases a given element. Preserves the original inert state
+   * so externally-inerted elements are not inadvertently re-enabled.
+   * @private
+   */
+  _clearPageInert() {
+    if (this._inertSiblings) {
+      for (const sibling of this._inertSiblings) {
+        const count = parseInt(sibling.dataset.auroInertCount || '1', 10) - 1;
+        if (count <= 0) {
+          const wasInert = sibling.dataset.auroInertWas === 'true';
+          delete sibling.dataset.auroInertCount;
+          delete sibling.dataset.auroInertWas;
+          sibling.inert = wasInert;
+        } else {
+          sibling.dataset.auroInertCount = String(count);
+        }
+      }
+      this._inertSiblings = undefined;
     }
   }
 
@@ -5836,6 +6104,7 @@ class AuroDropdown extends AuroElement$2 {
           shape="${this.shape}"
           ?data-show="${this.isPopoverVisible}"
           ?isfullscreen="${this.isBibFullscreen}"
+          ?desktopmodal="${this.desktopModal}"
           .dialogLabel="${this.bibDialogLabel}"
           ${ref(this.bibElement)}
           >
@@ -10410,7 +10679,7 @@ class AuroFormValidation {
       } else if (this.runtimeUtils.elementMatch(elem, 'auro-input') && elem.errorMessage === '') {
         const input = elem.renderRoot.querySelector('input');
 
-        if (input.validationMessage.length > 0) {
+        if (input && input.validationMessage.length > 0) {
           elem.errorMessage = input.validationMessage;
         }
       } else if (this.runtimeUtils.elementMatch(elem, 'auro-combobox') && elem.errorMessage === '') {
@@ -16082,7 +16351,11 @@ class AuroInputUtilities {
             return part.value;
         }
       })
-      .join("");
+      .join("")
+      // Remove whitespace and leading/trailing special characters for IMask compatibility
+      // for example, ko-KR's format is `YYYY. MM. DD.` which causes issues with IMask if we don't remove the trailing period.
+      .replace(/\s/gu, '')
+      .replace(/^[^A-Z0-9]+|[^A-Z0-9]+$/gu, '');
   }
 
   /**
@@ -16238,27 +16511,16 @@ class AuroInputUtilities {
    * Converts a model value to a display value for the input element.
    * For full date formats, converts an ISO model value to the configured display format.
    * @private
-   * @param {string} value - The model value (ISO string for date types).
    * @param {Date|undefined} valueObject - Date object representation of value.
    * @param {string} format - The date format string.
-   * @returns {string}
+   * @returns {string | undefined}
    */
-  toFormattedValue(value, valueObject, format) {
-    if (!this.isFullDateFormat('date', format) || !value) {
-      return value;
-    }
-
-    if (!dateFormatter.isValidDate(value)) {
-      // For ISO-pattern strings that fail range validation (e.g. '2024-99-99'),
-      // return '' so inputElement stays empty and format-based validation is not triggered.
-      return (/^\d{4}-\d{2}-\d{2}$/u).test(value) ? '' : value;
-    }
-
+  toFormattedValue(valueObject, format) {
     const normalizedFormat = format.toLowerCase();
     const maskOptions = this.getMaskOptions('date', normalizedFormat);
 
     if (!(valueObject instanceof Date) || Number.isNaN(valueObject.getTime()) || !maskOptions || typeof maskOptions.format !== 'function') {
-      return value;
+      return undefined;
     }
 
     return maskOptions.format(valueObject);
@@ -16960,7 +17222,7 @@ class BaseInput extends AuroElement$1 {
    * @returns {Date|undefined}
    */
   get valueObject() {
-    return this._valueObject;
+    return this._valueObject || this._computeDateObjectFallback(this.value);
   }
 
   /**
@@ -16968,7 +17230,7 @@ class BaseInput extends AuroElement$1 {
    * @returns {Date|undefined}
    */
   get minObject() {
-    return this._minObject;
+    return this._minObject || this._computeDateObjectFallback(this.min);
   }
 
   /**
@@ -16976,7 +17238,31 @@ class BaseInput extends AuroElement$1 {
    * @returns {Date|undefined}
    */
   get maxObject() {
-    return this._maxObject;
+    return this._maxObject || this._computeDateObjectFallback(this.max);
+  }
+
+  /**
+   * Parses a date string into a Date object when the corresponding `_*Object`
+   * field hasn't been synced yet by `updated()`. Returns undefined when the
+   * input type/format isn't a full date or the string is not a valid date.
+   *
+   * Why this exists: a parent (datepicker) can call `inputN.validate()` from
+   * inside its own `updated()` before this input's `updated()` has run
+   * `syncDateValues()` — so `_valueObject`/`_maxObject` are still `undefined`
+   * and range checks would otherwise silently no-op (flipping the result to
+   * `valid` or `patternMismatch`).
+   * @private
+   * @param {string|undefined} dateStr - ISO date string from `value`/`min`/`max`.
+   * @returns {Date|undefined}
+   */
+  _computeDateObjectFallback(dateStr) {
+    if (!dateStr || !this.util || !this.util.isFullDateFormat(this.type, this.format)) {
+      return undefined;
+    }
+    if (!dateFormatter.isValidDate(dateStr)) {
+      return undefined;
+    }
+    return dateFormatter.stringToDateInstance(dateStr);
   }
 
   /**
@@ -17001,8 +17287,30 @@ class BaseInput extends AuroElement$1 {
   connectedCallback() {
     super.connectedCallback();
 
+    // Mark for query selectors when registered under a versioned tag (e.g. inside
+    // a datepicker/combobox). Must run before parent components call validate() on
+    // their inner inputs — the validation framework matches via tag-or-attribute,
+    // and parents trigger validation during their own updated() cycle, which can
+    // precede this input's firstUpdated().
+    if (this.tagName.toLowerCase() !== 'auro-input' && !this.hasAttribute('auro-input')) {
+      this.setAttribute('auro-input', '');
+    }
+
     this.locale = this.domHandler.getLocale(this);
     notifyOnLangChange(this);
+
+    // Pre-compute lengthForType and date-object fields so a parent (e.g. datepicker)
+    // calling our validate() synchronously during its own updated() cycle sees
+    // populated values. Without this, range validation silently no-ops because
+    // `max.length === lengthForType` fails when lengthForType is still undefined.
+    // Rebuild util here (constructor seeded with en-US default) so configureDataForType's
+    // locale-derived format lookup uses the actual locale just resolved above.
+    this.util = new AuroInputUtilities({
+      locale: this.locale,
+      format: this.format
+    });
+    this.configureDataForType();
+    this.syncDateValues();
   }
 
   disconnectedCallback() {
@@ -17023,8 +17331,8 @@ class BaseInput extends AuroElement$1 {
     }
 
     // add attribute for query selectors when auro-input is registered under a custom name
-    if (this.tagName.toLowerCase() !== 'auro-input') {
-      this.setAttribute('auro-input', true);
+    if (this.tagName.toLowerCase() !== 'auro-input' && !this.hasAttribute('auro-input')) {
+      this.setAttribute('auro-input', '');
     }
     this.inputId = this.id ? `${this.id}-input` : window.crypto.randomUUID();
 
@@ -17072,6 +17380,12 @@ class BaseInput extends AuroElement$1 {
             return;
           }
 
+          // While configureAutoFormatting is running, imask's internal updateControl
+          // writes el.value to align display with the masked value. A synthetic input
+          // event from that write would re-enter handleInput → processCreditCard mid-setup
+          // and clobber a Lit value that was just pushed by the parent combobox.
+          if (component._configuringMask) return;
+
           // If all guard clauses are passed, dispatch the event
           const inputEvent = new InputEvent('input', {
             bubbles: true,
@@ -17176,11 +17490,30 @@ class BaseInput extends AuroElement$1 {
         this.hasValue = false;
       }
 
-      const formattedValue = this.type === 'date' ? this.util.toFormattedValue(this.value, this.valueObject, this.format) : this.value;
+      let formattedValue = this.value;
+      if (this.type === 'date') {
+        const formattedDate = this.util.toFormattedValue(this.valueObject, this.format);
+        if (!formattedDate) {
+          // if user entered unrecognized date format that cannot be parsed into a Date object,
+          // keep the raw value in the input so they can edit it instead of overwriting with an empty string
+          formattedValue = this.value;
+        } else {
+          formattedValue = formattedDate;
+        }
+      }
 
       if (formattedValue !== this.inputElement.value) {
         this.skipNextProgrammaticInputEvent = true;
-        if (formattedValue) {
+        if (this.maskInstance && this.type === 'credit-card') {
+          // Route through the mask so its _value and el.value stay in lock-step
+          // (set value calls updateControl which writes el.value = displayValue).
+          // Writing el.value directly leaves the mask thinking displayValue is
+          // stale; _saveSelection on the next focus/click then warns. Scoped to
+          // credit-card so date's own formattedValue (raw ISO when calendar-invalid)
+          // isn't re-masked through the mm/dd/yyyy mask, which would truncate it
+          // and flip validity from patternMismatch to tooShort.
+          this.maskInstance.value = formattedValue || '';
+        } else if (formattedValue) {
           this.inputElement.value = formattedValue;
         } else {
           this.inputElement.value = '';
@@ -17289,58 +17622,73 @@ class BaseInput extends AuroElement$1 {
    * @returns {void}
    */
   configureAutoFormatting() {
-    if (this.maskInstance) {
-      this.maskInstance.destroy();
-    }
-
-    // Pass new format to util
-    this.util.updateFormat(this.format);
+    // Re-entrancy guard. The patched-setter's synthetic input event (suppressed
+    // by _configuringMask above) could otherwise trigger handleInput →
+    // processCreditCard → configureAutoFormatting before the outer call's
+    // set value has finished its alignCursor pass.
+    if (this._configuringMask) return;
+    this._configuringMask = true;
+    try {
+      if (this.maskInstance) {
+        this.maskInstance.destroy();
+      }
 
-    const maskOptions = this.util.getMaskOptions(this.type, this.format);
+      // Pass new format to util
+      this.util.updateFormat(this.format);
 
-    if (this.inputElement && maskOptions.mask) {
+      const maskOptions = this.util.getMaskOptions(this.type, this.format);
 
-      // Stash and clear any existing value before IMask init.
-      // IMask's constructor processes the current input value which requires
-      // selection state — clearing first avoids that scenario entirely.
-      // When the format changes (e.g. locale switch) and we have a valid ISO
-      // model value, compute the display string for the NEW format instead of
-      // re-using the old display string, which may be invalid in the new mask.
-      let existingValue = this.inputElement.value;
-      if (
-        this.util.isFullDateFormat(this.type, this.format) &&
-        this.value &&
-        dateFormatter.isValidDate(this.value) &&
-        this.valueObject instanceof Date &&
-        !Number.isNaN(this.valueObject.getTime()) &&
-        typeof maskOptions.format === 'function'
-      ) {
-        existingValue = maskOptions.format(this.valueObject);
-      }
+      if (this.inputElement && maskOptions.mask) {
 
-      this.skipNextProgrammaticInputEvent = true;
-      this.inputElement.value = '';
+        // Stash and clear any existing value before IMask init.
+        // IMask's constructor processes the current input value which requires
+        // selection state — clearing first avoids that scenario entirely.
+        // When the format changes (e.g. locale switch) and we have a valid ISO
+        // model value, compute the display string for the NEW format instead of
+        // re-using the old display string, which may be invalid in the new mask.
+        let existingValue = this.inputElement.value;
+        if (
+          this.util.isFullDateFormat(this.type, this.format) &&
+          this.value &&
+          dateFormatter.isValidDate(this.value) &&
+          this.valueObject instanceof Date &&
+          !Number.isNaN(this.valueObject.getTime()) &&
+          typeof maskOptions.format === 'function'
+        ) {
+          existingValue = maskOptions.format(this.valueObject);
+        }
 
-      this.maskInstance = IMask(this.inputElement, maskOptions);
+        this.skipNextProgrammaticInputEvent = true;
+        this.inputElement.value = '';
+
+        this.maskInstance = IMask(this.inputElement, maskOptions);
+
+        this.maskInstance.on('accept', () => {
+          // Suppress propagation during configureAutoFormatting's own value-restoration
+          // (line below) — the mask emits 'accept' on every value-set, including ours,
+          // and we don't want to overwrite a value the parent just pushed.
+          if (this._configuringMask) return;
+          this.value = this.util.toModelValue(this.maskInstance.value, this.format);
+          if (this.type === "date") {
+            this._rawMaskValue = this.maskInstance.value;
+          }
+        });
 
-      this.maskInstance.on('accept', () => {
-        this.value = this.util.toModelValue(this.maskInstance.value, this.format);
-        if (this.type === "date") {
-          this._rawMaskValue = this.maskInstance.value;
-        }
-      });
+        this.maskInstance.on('complete', () => {
+          if (this._configuringMask) return;
+          this.value = this.util.toModelValue(this.maskInstance.value, this.format);
+          if (this.type === "date") {
+            this._rawMaskValue = this.maskInstance.value;
+          }
+        });
 
-      this.maskInstance.on('complete', () => {
-        this.value = this.util.toModelValue(this.maskInstance.value, this.format);
-        if (this.type === "date") {
-          this._rawMaskValue = this.maskInstance.value;
+        // Restore the stashed value through IMask so it's properly masked
+        if (existingValue) {
+          this.maskInstance.value = existingValue;
         }
-      });
-
-      // Restore the stashed value through IMask so it's properly masked
-      if (existingValue) {
-        this.maskInstance.value = existingValue;
       }
+    } finally {
+      this._configuringMask = false;
     }
   }
 
@@ -17627,10 +17975,10 @@ class BaseInput extends AuroElement$1 {
       },
       {
         name: 'Diners club',
-        regex: /^(?<num>36|38)\d{0}/u,
+        regex: /^(?<num>30[0-5]|36|38)\d{0}/u,
         formatLength: 16,
         errorMessage: CreditCardValidationMessage,
-        cardIcon: 'credit-card',
+        cardIcon: 'cc-dinersclub',
         maskFormat: "0000 000000 0000"
       },
       {
@@ -18040,7 +18388,7 @@ let AuroHelpText$1 = class AuroHelpText extends LitElement {
   }
 };
 
-var formkitVersion$1 = '202606031942';
+var formkitVersion$1 = '202606181613';
 
 // Copyright (c) 2025 Alaska Airlines. All right reserved. Licensed under the Apache-2.0 license
 // See LICENSE in the project root for license information.
@@ -18378,10 +18726,6 @@ class AuroInput extends BaseInput {
       return i18n(this.lang, this.type);
     }
 
-    if (this.type === 'date') {
-      return i18n(this.lang, this.dateFormatMap[this.format] || 'dateMMDDYYYY');
-    }
-
     return '';
   }
 
@@ -19046,6 +19390,14 @@ class AuroBibtemplate extends LitElement {
       large: {
         type: Boolean,
         reflect: true
+      },
+
+      /**
+       * If declared, the footer slot will be rendered even when not in fullscreen mode.
+       */
+      showFooter: {
+        type: Boolean,
+        reflect: true
       }
     };
   }
@@ -19148,7 +19500,7 @@ class AuroBibtemplate extends LitElement {
           <slot></slot>
         </div>
 
-      ${this.isFullscreen ? html`
+      ${this.isFullscreen || this.showFooter ? html`
         <div id="footerContainer">
           <slot name="footer"></slot>
         </div>` : null}
@@ -19157,7 +19509,7 @@ class AuroBibtemplate extends LitElement {
   }
 }
 
-var formkitVersion = '202606031942';
+var formkitVersion = '202606181613';
 
 var styleCss$1 = css`.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}`;
 
@@ -19514,6 +19866,25 @@ function normalizeFilterValue(value) {
   return raw.trim() ? raw.trimEnd() : raw;
 }
 
+/**
+ * Returns the option's plain-text label suitable for input.value, with
+ * HTML-indentation whitespace collapsed and the displayValue slot text
+ * removed (the slot renders separately in the trigger).
+ * @param {HTMLElement} option - An auro-menuoption element.
+ * @returns {string} Normalized label.
+ */
+function getOptionLabel(option) {
+  if (!option) {
+    return '';
+  }
+  const clone = option.cloneNode(true);
+  const displayValueEl = clone.querySelector('[slot="displayValue"]');
+  if (displayValueEl) {
+    displayValueEl.remove();
+  }
+  return (clone.textContent || '').replace(/\s+/gu, ' ').trim();
+}
+
 // See https://git.io/JJ6SJ for "How to document your components using JSDoc"
 /**
  * The `auro-combobox` element provides users with a way to select an option from a list of filtered or suggested options based on user input.
@@ -19641,7 +20012,19 @@ class AuroCombobox extends AuroElement {
       availableOptions: {
         state: true,
         type: Array,
-        reflect: false
+        reflect: false,
+        hasChanged(newVal, oldVal) {
+          if (!oldVal && !newVal) {
+            return false;
+          }
+          if (!oldVal || !newVal) {
+            return true;
+          }
+          if (newVal.length !== oldVal.length) {
+            return true;
+          }
+          return newVal.some((opt, idx) => opt !== oldVal[idx]);
+        }
       },
 
       /**
@@ -20072,18 +20455,15 @@ class AuroCombobox extends AuroElement {
         matchString = `${matchString} ${option.getAttribute('suggest')}`.toLowerCase();
       }
 
-      // If input is empty, show all options (except static ones)
-      if (!filterValue) {
-        if (!option.hasAttribute('static')) {
-          option.removeAttribute('hidden');
-          this.availableOptions.push(option);
-        }
-      } else if (matchString.includes(filterValue) && !option.hasAttribute('static')) {
-        // only count options that match the typed input value AND are not static
+      if (!filterValue && option.hasAttribute('static')) {
+        // Static options are shown when the input is empty so consumers can
+        // surface headers / "add new" rows when no filter is active.
+        option.removeAttribute('hidden');
+        this.availableOptions.push(option);
+      } else if (filterValue && matchString.includes(filterValue) && !option.hasAttribute('static')) {
         option.removeAttribute('hidden');
         this.availableOptions.push(option);
       } else if (!option.hasAttribute('persistent')) {
-        // Hide all other non-persistent options
         option.setAttribute('hidden', '');
         option.removeAttribute('aria-setsize');
         option.removeAttribute('aria-posinset');
@@ -20091,7 +20471,9 @@ class AuroCombobox extends AuroElement {
     });
 
     if (this.availableOptions.length === 0) {
-      if (this.noMatchOption) {
+      // Only surface the nomatch option once the user has actually typed
+      // something. Empty input is handled by the bib being closed.
+      if (this.noMatchOption && filterValue) {
         this.noMatchOption.removeAttribute('hidden');
       } else if (!this.menu.loading || this.isHiddenWhileLoading) {
         this.hideBib();
@@ -20107,11 +20489,14 @@ class AuroCombobox extends AuroElement {
    * @returns {void}
    */
   syncValuesAndStates() {
-    // Only sync matchWord, don't set menu.value here since setMenuValue should handle that
+    // Do NOT call setMenuValue here — the caller (handleMenuOptions) already
+    // guards setMenuValue with an option-match check. Calling it unconditionally
+    // sets free-form values on the menu, triggering clearSelection which resets
+    // _index and breaks subsequent makeSelection calls.
     if (this.menu) {
       this.menu.matchWord = normalizeFilterValue(this.input.value);
     }
-    const label = this.menu.currentLabel;
+    const label = getOptionLabel(this.menu.optionSelected) || this.menu.currentLabel;
     this.updateTriggerTextDisplay(label || this.value);
   }
 
@@ -20126,7 +20511,39 @@ class AuroCombobox extends AuroElement {
     const isInputFocusedWithNoSelection = !this.menu.value && (this.input.matches(':focus-within') || (this.inputInBib && this.inputInBib.matches(':focus-within')));
 
     if (!this.persistInput && !(this.behavior === 'suggestion' && isInputFocusedWithNoSelection)) {
-      this.input.value = label || this.value;
+      const nextValue = label || this.value;
+      // Only set the flag when there's an actual write to suppress —
+      // syncValuesAndStates re-enters here during typing when both inputs
+      // already match, and a no-op flag flip would make the bib branch's
+      // bail eat legitimate user-input events.
+      const triggerNeedsSync = this.input.value !== nextValue;
+      const bibNeedsSync = Boolean(this.inputInBib && this.inputInBib !== this.input && this.inputInBib.value !== nextValue);
+      if (triggerNeedsSync || bibNeedsSync) {
+        this._syncingDisplayValue = true;
+        if (triggerNeedsSync) {
+          this.input.value = nextValue;
+        }
+        if (bibNeedsSync) {
+          this.inputInBib.value = nextValue;
+        }
+        const pending = [];
+        if (triggerNeedsSync) {
+          pending.push(this.input.updateComplete);
+        }
+        if (bibNeedsSync) {
+          pending.push(this.inputInBib.updateComplete);
+        }
+        Promise.all(pending).then(() => {
+          // imask reasserts otherwise, and handleBlur reverts to its stale value.
+          if (triggerNeedsSync && this.input.maskInstance && typeof this.input.maskInstance.updateValue === 'function') {
+            this.input.maskInstance.updateValue();
+          }
+          if (bibNeedsSync && this.inputInBib && this.inputInBib.maskInstance && typeof this.inputInBib.maskInstance.updateValue === 'function') {
+            this.inputInBib.maskInstance.updateValue();
+          }
+          this._syncingDisplayValue = false;
+        });
+      }
     }
 
     // update the displayValue in the trigger if displayValue slot content is present
@@ -20140,6 +20557,14 @@ class AuroCombobox extends AuroElement {
       const displayValueEl = this.menu.optionSelected.querySelector("[slot='displayValue']");
       if (displayValueEl) {
         this.input.appendChild(displayValueEl.cloneNode(true));
+        // auro-input's hasDisplayValueContent is non-reactive; nudge it to
+        // re-evaluate the slot and re-render so the displayValue wrapper
+        // gets its hasContent class. Without this, the apple/icon stays
+        // hidden when input.value is set in the same tick as the append.
+        if (typeof this.input.checkDisplayValueSlotChange === 'function') {
+          this.input.checkDisplayValueSlotChange();
+          this.input.requestUpdate();
+        }
       }
     }
 
@@ -20173,7 +20598,10 @@ class AuroCombobox extends AuroElement {
       this.syncValuesAndStates();
     }
 
-    if (!this.availableOptions.includes(this.menu.optionActive)) {
+    // Re-activate when optionActive is no longer visible, or when _index has
+    // been reset (e.g. by clearSelection in an async update) so that
+    // makeSelection() can find the correct option.
+    if (!this.availableOptions.includes(this.menu.optionActive) || this.menu._index < 0) {
       this.activateFirstEnabledAvailableOption();
     }
   }
@@ -20269,6 +20697,14 @@ class AuroCombobox extends AuroElement {
         // keyboard navigation continues from the correct place in the page
         if (this.dropdown.isBibFullscreen) {
           restoreTriggerAfterClose(this.dropdown, this.input);
+
+          // After the rAF inside restoreTriggerAfterClose() refocuses the
+          // trigger, park the caret at end-of-text. Without this, the trigger
+          // shows the new value (e.g. "Peaches") but its caret sits at [0, 0]
+          // because nothing wrote to the native input between close and focus.
+          doubleRaf(() => {
+            this.setInputFocus();
+          });
         }
       }
 
@@ -20298,12 +20734,27 @@ class AuroCombobox extends AuroElement {
 
           guardTouchPassthrough(this.menu);
 
-          // Wait for the bibtemplate to fully render across
-          // multiple Lit update cycles before moving focus into the bib
+          // The dialog's showModal() steals focus from the trigger.
+          // A single rAF is enough for the dialog DOM to be painted and
+          // focusable, then doubleRaf finalizes the transition.
+          requestAnimationFrame(() => {
+            this.setInputFocus();
+          });
+
           doubleRaf(() => {
             this.setInputFocus();
             this._inFullscreenTransition = false;
           });
+        } else {
+          // Desktop popover-open: restore the trigger caret to end-of-text.
+          // Clicking the trigger lands on auro-input's floating <label for="…">
+          // overlay; Chrome resets the native input's selection to [0, 0] on
+          // label-focus before any JS runs. setInputFocus()'s non-fullscreen
+          // branch parks the caret at end. doubleRaf lets the dropdown layout
+          // settle first, matching the fullscreen branch timing.
+          doubleRaf(() => {
+            this.setInputFocus();
+          });
         }
       }
     });
@@ -20380,21 +20831,52 @@ class AuroCombobox extends AuroElement {
    */
   setInputFocus() {
     if (this.dropdown.isBibFullscreen && this.dropdown.isPopoverVisible) {
-      this.inputInBib.focus();
+      // Sync the native input value synchronously before focusing.
+      // Lit's property-to-attribute sync is async (microtask), so the
+      // native <input> inside inputInBib may still hold a stale value
+      // when focus moves here during the fullscreen transition. Without
+      // this, keystrokes (e.g. Backspace) operate on the wrong content.
+      const nativeInput = this.inputInBib.inputElement;
+      const triggerNativeInput = this.input.inputElement;
+      if (nativeInput && triggerNativeInput && nativeInput.value !== triggerNativeInput.value) {
+        this.inputInBib.skipNextProgrammaticInputEvent = true;
+        nativeInput.value = triggerNativeInput.value || '';
+      }
+
+      // Focus the native input directly to ensure it receives keystrokes
+      // after the fullscreen dialog opens. The dialog's showModal() may
+      // have moved focus to the dialog element itself; focusing the
+      // auro-input custom element doesn't always reach the native input
+      // when the dialog DOM isn't fully painted.
+      if (nativeInput) {
+        nativeInput.focus();
+      } else {
+        this.inputInBib.focus();
+      }
 
       // Place cursor at end of existing text so the user can continue editing
-      const nativeInput = this.inputInBib.inputElement;
       if (nativeInput && nativeInput.value) {
         const len = nativeInput.value.length;
         nativeInput.setSelectionRange(len, len);
       }
-    } else if (!this.input.componentHasFocus) {
-      const focusedEl = this.querySelector(":focus");
-      this.input.focus();
-      // current focus is on a menuoption, after clicking on it.
-      if (this.persistInput && focusedEl && (focusedEl.tagName.toLowerCase() === 'auro-menuoption' || focusedEl.hasAttribute('auro-menuoption'))) {
-        this.setClearBtnFocus();
-        this.validate(true);
+    } else {
+      // Safety net for the strategy-change setTimeout: a viewport-crossing
+      // fullscreen→floating switch can close the dialog and leave focus on
+      // body. Every other Branch 2 callsite already has focus on the input
+      // via the focusin → this.focus() redirect (L1448-1452), so this is a
+      // no-op in the common case.
+      if (!this.input.componentHasFocus) {
+        this.input.focus();
+      }
+
+      // Park the trigger native input's caret at end-of-text every time the
+      // popover opens. Chrome focuses the native via the floating <label for="…">
+      // overlay on click and resets selection to [0, 0]; no JS fires between
+      // mousedown and selectionchange, so we restore the caret here.
+      const triggerNativeInput = this.input.inputElement;
+      if (triggerNativeInput && triggerNativeInput.value) {
+        const len = triggerNativeInput.value.length;
+        triggerNativeInput.setSelectionRange(len, len);
       }
     }
   }
@@ -20491,53 +20973,92 @@ class AuroCombobox extends AuroElement {
       this.menu.setAttribute('nocheckmark', '');
     }
 
-    this.menu.addEventListener("auroMenu-deselectPrevented", () => {
-      this.hideBib();
-    });
+    // Handle menu option selection
+    this.menu.addEventListener('auroMenu-selectedOption', (evt) => {
+      // Capture before the consumption below — true means this event is the
+      // echo of our own setMenuValue (programmatic value sync), false means
+      // a fresh user selection.
+      const isEcho = this._pendingMenuValueSync === true;
 
-    // Handle menu option selection like select does
-    this.menu.addEventListener('auroMenu-selectedOption', (event) => {
-      // Update the optionSelected from the event details, not manually
-      [this.optionSelected] = event.detail.options;
+      if (this.menu.optionSelected) {
+        const selected = this.menu.optionSelected;
 
-      // Update the internal value to match the menu's value
-      this.value = event.detail.stringValue;
+        if (!this.optionSelected || this.optionSelected !== selected) {
+          this.optionSelected = selected;
+        }
 
-      // Update display
-      this.updateTriggerTextDisplay(event.detail.label || event.detail.value);
+        // Skip writeback when this event is the echo of our own setMenuValue —
+        // otherwise it cascades against handleInputValueChange in suggestion mode.
+        if (this._pendingMenuValueSync) {
+          this._pendingMenuValueSync = false;
+        } else if (!this.value || this.value !== this.optionSelected.value) {
+          this.value = this.optionSelected.value;
+        }
 
-      // Update match word for filtering
-      const trimmedInput = normalizeFilterValue(this.input.value);
-      if (this.menu.matchWord !== trimmedInput) {
-        this.menu.matchWord = trimmedInput;
-      }
+        // Update display
+        this.updateTriggerTextDisplay(getOptionLabel(this.optionSelected) || this.menu.value);
 
-      // Update available options based on selection
-      this.handleMenuOptions();
+        // Update match word for filtering
+        const trimmedInput = normalizeFilterValue(this.input.value);
+        if (this.menu.matchWord !== trimmedInput) {
+          this.menu.matchWord = trimmedInput;
+        }
+      }
 
       // Hide dropdown on selection (except during slot changes)
-      if (event.detail && event.detail.source !== 'slotchange') {
-        setTimeout(() => {
-          // do not close while typing in suggestion mode with no value selected, to allow freeform input
-          if (this.menu.value || this.behavior !== 'suggestion') {
-            this.hideBib();
-          }
-        }, 0);
+      if (evt.detail && evt.detail.source !== 'slotchange') {
+        // do not close while typing in suggestion mode with no value selected, to allow freeform input
+        if (this.menu.value || this.behavior !== 'suggestion') {
+          this.hideBib();
+        }
 
         // Announce the selection after the dropdown closes so it isn't
         // overridden by VoiceOver's "collapsed" announcement from aria-expanded.
-        const selectedValue = event.detail.stringValue;
+        const selectedValue = this.menu.value;
         const announcementDelay = 300;
         setTimeout(() => {
           announceToScreenReader(this._getAnnouncementRoot(), `${selectedValue}, selected`);
         }, announcementDelay);
       }
+
+      // Programmatic value syncs leave availableOptions stale because
+      // updateTriggerTextDisplay sets input.value with _syncingDisplayValue
+      // and handleInputValueChange bails. Refresh the filter on echo events
+      // only — fresh user selections take the existing hideBib path.
+      if (isEcho && this.menu.optionSelected) {
+        this._programmaticFilterRefresh = true;
+        this.handleMenuOptions();
+        setTimeout(() => {
+          this._programmaticFilterRefresh = false;
+        }, 0);
+      }
+
+      // base-input skips auto-validate when focus is inside its own shadow,
+      // which it is after setTriggerInputFocus — re-run so prior tooShort
+      // clears. processCreditCard reasserts errorMessage on every render.
+      if (!isEcho && this.menu.optionSelected && this.input.validate) {
+        this.input.updateComplete.then(() => {
+          this.input.validate(true);
+          if (this.input.validity === 'valid') {
+            this.input.errorMessage = '';
+          }
+        });
+      }
     });
 
     this.menu.addEventListener('auroMenu-customEventFired', () => {
       this.hideBib();
     });
 
+    // When the menu cannot match a programmatic value to any option,
+    // clear the combobox selection state so it doesn't reference a
+    // stale option. Safe from re-entrancy because any resulting
+    // input.value changes dispatch isProgrammatic events.
+    this.menu.addEventListener('auroMenu-selectValueFailure', () => {
+      this.value = undefined;
+      this.optionSelected = undefined;
+    });
+
     this.menu.addEventListener('auroMenu-activatedOption', (evt) => {
       this.optionActive = evt.detail;
 
@@ -20638,11 +21159,12 @@ class AuroCombobox extends AuroElement {
     // event from the trigger. The _syncingBibValue guard persists across the
     // async boundary and prevents that re-entrant event from running the
     // non-fullscreen path (which would call clear() → hideBib()).
-    // When the event comes from the fullscreen bib input, sync the value to
-    // the trigger and run filtering, but suppress the re-entrant input event
-    // that the trigger fires (via Lit updated() → notifyValueChanged()) so
-    // the non-fullscreen hide/clear logic doesn't close the dialog.
     if (event.target === this.inputInBib) {
+      // Mirror the trigger-branch bail below — programmatic inputInBib writes
+      // notify back into this branch via Lit's notifyValueChanged.
+      if (this._syncingDisplayValue) {
+        return;
+      }
       this._syncingBibValue = true;
       this.input.value = this.inputInBib.value;
       this.input.updateComplete.then(() => {
@@ -20652,18 +21174,37 @@ class AuroCombobox extends AuroElement {
       // Run filtering inline — the re-entrant event won't reach this code.
       this.menu.matchWord = normalizeFilterValue(this.inputInBib.value);
       this.optionActive = null;
+
+      // In suggestion mode, keep the combobox value in sync with the typed
+      // text so that freeform values are captured (mirroring the non-fullscreen
+      // path). Clear the selection when the input is emptied.
+      if (this.behavior === 'suggestion') {
+        this.value = this.inputInBib.value || undefined;
+      }
+
       this.handleMenuOptions();
       this.dispatchEvent(new CustomEvent('inputValue', { detail: { value: this.inputValue } }));
       return;
     }
 
-    // Ignore re-entrant input events caused by the bib→trigger sync above.
-    if (this._syncingBibValue) {
+    // Ignore re-entrant input events caused by programmatic value sets.
+    if (this._syncingBibValue || this._syncingDisplayValue) {
       return;
     }
 
     this.inputInBib.value = this.input.value;
 
+    // Also sync the native input immediately so keystrokes arriving
+    // before Lit's async update cycle (e.g. rapid Backspaces during a
+    // fullscreen transition) operate on the correct content.
+    // Skip the next programmatic input event to prevent the patched setter
+    // from re-entering handleInputValueChange via the bib path.
+    const bibNativeInput = this.inputInBib.inputElement;
+    if (bibNativeInput && bibNativeInput.value !== this.input.value) {
+      this.inputInBib.skipNextProgrammaticInputEvent = true;
+      bibNativeInput.value = this.input.value || '';
+    }
+
     this.menu.matchWord = normalizeFilterValue(this.input.value);
     this.optionActive = null;
 
@@ -20671,7 +21212,7 @@ class AuroCombobox extends AuroElement {
       this.value = this.input.value;
     }
 
-    if (!this.input.value) {
+    if (!this.input.value && !this._clearing) {
       this.clear();
     }
     this.handleMenuOptions();
@@ -20740,6 +21281,16 @@ class AuroCombobox extends AuroElement {
         return;
       }
 
+      // Ignore dispatches from the bib (fullscreen) input. It's re-validated
+      // inside this.validate()'s auroInputElements loop with its own
+      // (often undefined) validity, and the event is composed/bubbles up to
+      // this listener with `target` retargeted to the combobox. Letting it
+      // through would overwrite the trigger input's correct validity with
+      // the bib input's stale one (e.g. wiping `tooShort` during typing).
+      if (this.inputInBib && evt.composedPath()[0] === this.inputInBib && this.inputInBib !== this.input) {
+        return;
+      }
+
       this.input.validity = evt.detail.validity;
       this.input.errorMessage = evt.detail.message;
       this.validity = evt.detail.validity;
@@ -20801,10 +21352,18 @@ class AuroCombobox extends AuroElement {
    * @returns {void}
    */
   setMenuValue(value) {
-    if (!this.menu) {
+    if (!this.menu || this.menu.value === value) {
       return;
     }
+    // One-shot flag consumed by the auroMenu-selectedOption listener so the
+    // echo of this sync doesn't propagate back to this.value.
+    this._pendingMenuValueSync = true;
     this.menu.value = value;
+    // Backup clear: if menu.value === menu.optionSelected.value already, the
+    // listener won't fire and the flag would swallow the next user click.
+    setTimeout(() => {
+      this._pendingMenuValueSync = false;
+    }, 0);
   }
 
   /**
@@ -20819,6 +21378,15 @@ class AuroCombobox extends AuroElement {
     this.menu.value = undefined;
     this.validation.reset(this);
     this.touched = false;
+    // Force validity back to the cleared state. validation.reset() calls
+    // validate() at the end, and (post-credit-card-fix) the trigger input's
+    // residual validity may still be copied into the combobox by the
+    // auroInputElements loop. Explicitly clear here so reset() actually
+    // leaves the component in a "no validity" state.
+    this.validity = undefined;
+    this.errorMessage = '';
+    this.input.validity = undefined;
+    this.input.errorMessage = '';
   }
 
   /**
@@ -20826,16 +21394,24 @@ class AuroCombobox extends AuroElement {
    * @returns {void}
    */
   clear() {
-    // Clear combobox state first
-    this.optionSelected = undefined;
-    this.value = undefined;
-
-    // Then clear input and menu
-    if (this.input.value) {
-      this.input.clear();
+    // input.clear() fires an input event that re-enters handleInputValueChange
+    // → which calls clear() again on empty input. Guard against that loop.
+    if (this._clearing) {
+      return;
     }
-    if (this.menu.value || this.menu.optionSelected) {
-      this.menu.reset();
+    this._clearing = true;
+    try {
+      this.optionSelected = undefined;
+      this.value = undefined;
+
+      if (this.input.value) {
+        this.input.clear();
+      }
+      if (this.menu.value || this.menu.optionSelected) {
+        this.menu.reset();
+      }
+    } finally {
+      this._clearing = false;
     }
   }
 
@@ -20863,29 +21439,64 @@ class AuroCombobox extends AuroElement {
         this.input.value = this.value;
       }
 
-      if (this.menu && this.hasValue && this.menu.options) {
-        this.menu.options.forEach((opt) => {
-          if (!opt.hasAttribute('static')) {
-            opt.removeAttribute('hidden');
-          }
-        });
-      }
-
-      if (this.behavior === 'suggestion') {
-        if (!this.menu.options || this.menu.options.length === 0) ; else if (this.menu.options.filter((opt) => opt.value === this.value).length > 0) {
+      // Sync menu.value only when an option actually matches; otherwise clear it.
+      if (this.menu.options && this.menu.options.length > 0) {
+        if (this.menu.options.some((opt) => opt.value === this.value)) {
+          this.setMenuValue(this.value);
+        } else if (this.behavior === 'filter') {
+          // In filter mode, freeform values aren't allowed. Push the unmatched
+          // value through setMenuValue so menu dispatches auroMenu-selectValueFailure
+          // and the listener at line 1206 clears combobox.value (mirrors select's
+          // pattern). Bypassing setMenuValue here would skip the failure cascade.
           this.setMenuValue(this.value);
         } else {
-          this.menu.value = undefined;
-          // Sync the input display for freeform values that don't match any option
-          this.input.value = this.value;
-        }
-      } else {
-        // Use setMenuValue like select does instead of direct assignment
-        this.setMenuValue(this.value);
-        if (!this.value) {
-          this.clear();
+          if (this.menu.value) {
+            this.menu.value = undefined;
+          }
+          // Sync the display for programmatic freeform value changes (e.g. the
+          // swap-values pattern). Guard with _syncingDisplayValue so that the
+          // re-entrant input event from base-input.notifyValueChanged() is
+          // ignored by handleInputValueChange. Skip the sync when input already
+          // matches to avoid spurious events during the normal typing path.
+          const nextValue = this.value || '';
+          const triggerNeedsSync = this.input.value !== nextValue;
+          const bibNeedsSync = Boolean(this.inputInBib && this.inputInBib !== this.input && this.inputInBib.value !== nextValue);
+          if (triggerNeedsSync || bibNeedsSync) {
+            this._syncingDisplayValue = true;
+            if (triggerNeedsSync) {
+              this.input.value = nextValue;
+            }
+            if (bibNeedsSync) {
+              this.inputInBib.value = nextValue;
+            }
+            const pending = [];
+            if (triggerNeedsSync) {
+              pending.push(this.input.updateComplete);
+            }
+            if (bibNeedsSync) {
+              pending.push(this.inputInBib.updateComplete);
+            }
+            Promise.all(pending).then(() => {
+              if (triggerNeedsSync && this.input.maskInstance && typeof this.input.maskInstance.updateValue === 'function') {
+                this.input.maskInstance.updateValue();
+              }
+              if (bibNeedsSync && this.inputInBib && this.inputInBib.maskInstance && typeof this.inputInBib.maskInstance.updateValue === 'function') {
+                this.inputInBib.maskInstance.updateValue();
+              }
+              this._syncingDisplayValue = false;
+              // handleInputValueChange bailed on the flag — refresh the filter.
+              this._programmaticFilterRefresh = true;
+              this.handleMenuOptions();
+              setTimeout(() => {
+                this._programmaticFilterRefresh = false;
+              }, 0);
+            });
+          }
         }
       }
+      if (!this.value) {
+        this.clear();
+      }
       if (this.value && !this.componentHasFocus) {
         // If the value got set programmatically make sure we hide the bib
         // when input is not taking the focus (input can be in dropdown.trigger or in bibtemplate)
@@ -20922,12 +21533,18 @@ class AuroCombobox extends AuroElement {
       // branch from calling hideBib() when the dropdown was just opened but
       // :focus-within hasn't propagated through the top-layer dialog's nested
       // shadow DOM boundaries.
-      if ((this.availableOptions.length > 0 && (this.componentHasFocus || this.dropdownOpen)) || (this.menu && this.menu.loading) || (this.availableOptions.length === 0 && this.noMatchOption)) {
+      // Skip the show/hide side effects when the availableOptions change came
+      // from a programmatic filter refresh after a value swap — the user
+      // didn't interact, so we shouldn't auto-open the bib (especially for
+      // the no-match path where the existing condition unconditionally fires).
+      if (this._programmaticFilterRefresh) {
+        this._programmaticFilterRefresh = false;
+      } else if ((this.availableOptions.length > 0 && (this.componentHasFocus || this.dropdownOpen)) || (this.menu && this.menu.loading) || (this.availableOptions.length === 0 && this.noMatchOption)) {
         this.showBib();
         if (!this.availableOptions.includes(this.menu.optionActive)) {
           this.activateFirstEnabledAvailableOption();
         }
-      } else {
+      } else if (this.dropdown && this.dropdown.isPopoverVisible) {
         this.hideBib();
       }
     }