@sapudex/web-components 2.61.0 → 2.62.0

package/cypress/specs/SelectBoxAccessibility.cy.tsx

@@ -0,0 +1,3109 @@
+import { UDExButton, UDExCountrySelector, UDExSelectBox, UDExSelectBoxGroupHeader, UDExSelectBoxItem, UDExSelectBoxSelectAll } from "../support/component-imports.js";
+import { UDExListMode } from "../../src/types/List.js";
+import type { UDExSearchableListBaseSelectionChangeEventDetail, UDExSelectBoxIconClickEventDetail } from "../../src/SearchableListBase.js";
+import type { UDExSelectBoxRemoveEventDetail } from "../../src/SelectBox.js";
+import type UDExSelectBoxElement from "../../src/SelectBox.js";
+import type UDExSelectBoxItemElement from "../../src/SelectBoxItem.js";
+import type UDExSelectBoxSelectAllElement from "../../src/SelectBoxSelectAll.js";
+import { renderFinished } from "@ui5/webcomponents-base/dist/Render.js";
+import { getTokensCountText } from "@ui5/webcomponents/dist/Tokenizer.js";
+import type Tokenizer from "@ui5/webcomponents/dist/Tokenizer.js";
+
+type UDExSelectBoxLayout = {
+  name: string;
+  grouped: boolean;
+  collapsible: boolean;
+};
+
+const UDExLayouts: UDExSelectBoxLayout[] = [
+  { name: "flat", grouped: false, collapsible: false },
+  { name: "grouped noncollapsible", grouped: true, collapsible: false },
+  { name: "grouped collapsible", grouped: true, collapsible: true },
+];
+const UDExModes = [UDExListMode.SingleContent, UDExListMode.SingleSelect, UDExListMode.MultiSelect] as const;
+type UDExSelectBoxMode = typeof UDExModes[number];
+const UDExInnerStateAttributes = ["tabindex", "aria-selected", "aria-checked", "aria-expanded", "aria-disabled", "aria-description"];
+
+const UDExCombobox = () => cy.get("[udex-select-box]").shadow().find('input[role="combobox"]');
+const UDExListHost = () => cy.get("[udex-select-box]").shadow().find("[udex-list]");
+const UDExHeaderHost = () => UDExListHost().find("[udex-list-group-header]");
+const UDExNestedHeader = () => UDExHeaderHost().shadow().find("[udex-list-item]#group-heading");
+const UDExLeafHost = (UDExLabel: string) => UDExListHost().find(`[udex-list-item][label="${UDExLabel}"]`);
+const UDExSourceLeaf = (UDExLabel: string) => cy.get("[udex-select-box]").find(`[udex-select-box-item][label="${UDExLabel}"]`);
+const UDExStatus = () => cy.get("[udex-select-box]").shadow().find('[aria-live="polite"]');
+const UDExPopover = () => cy.get("[udex-select-box]").shadow().find("[ui5-popover]");
+const UDExSelectAllHost = () => UDExListHost().find("[udex-list-select-all]");
+const UDExSelectAllRow = () => UDExSelectAllHost().shadow().find('[udex-list-item][part="group-item"]');
+
+function UDExMountClosedSelectBox(UDExMode: UDExSelectBoxMode, UDExLayout: UDExSelectBoxLayout, UDExWithFooter = false) {
+  const UDExItems = ["Alpha", "Beta", "Unavailable"].map(UDExLabel => (
+    <UDExSelectBoxItem label={UDExLabel} disabled={UDExLabel === "Unavailable"}></UDExSelectBoxItem>
+  ));
+
+  cy.mount(
+    <div id="select-box-regression-fixture">
+      <UDExSelectBox label="Languages" mode={UDExMode}>
+        {UDExLayout.grouped ? (
+          <UDExSelectBoxGroupHeader label="Languages group" collapsible={UDExLayout.collapsible}>
+            {UDExItems}
+          </UDExSelectBoxGroupHeader>
+        ) : UDExItems}
+        {UDExWithFooter && <UDExButton id="select-box-footer-action" slot="footer">Apply</UDExButton>}
+      </UDExSelectBox>
+      {UDExWithFooter && <button id="after-select-box">Next</button>}
+    </div>
+  );
+}
+
+function UDExMountSelectBox(UDExMode: UDExSelectBoxMode, UDExLayout: UDExSelectBoxLayout, UDExWithFooter = false) {
+  UDExMountClosedSelectBox(UDExMode, UDExLayout, UDExWithFooter);
+  UDExOpenSelectBox(UDExLayout);
+  // Updated: this fixture starts on an expanded header only in the collapsible layout.
+  UDExAssertOpeningStatus(UDExLayout.collapsible ? "" : "expanded");
+}
+
+function UDExOpenSelectBox(UDExLayout: UDExSelectBoxLayout) {
+  // Listen outside the component to also check selection-change bubbling.
+  cy.get("#select-box-regression-fixture").then($fixture => {
+    $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+  });
+  cy.get("[udex-select-box]").shadow().find("[ui5-popover]").then($popover => {
+    $popover[0].addEventListener("ui5-open", cy.stub().as("popoverOpened"), { once: true });
+  });
+  UDExCombobox().realClick();
+  cy.get("@popoverOpened").should("have.been.calledOnce");
+  cy.get("[udex-select-box]").shadow().find("[ui5-popover]").should("have.attr", "open");
+  // realClick dispatches coordinates without Cypress's normal animation checks.
+  // Opening the popup and expanding a group can still move or clip those coordinates.
+  cy.get("[udex-select-box]").shadow().find("[ui5-popover]").should($popover => {
+    expect($popover).not.to.have.class("ui5-popup-opening");
+    expect($popover[0].shadowRoot!.getAnimations().filter(UDExAnimation =>
+      UDExAnimation.pending || UDExAnimation.playState === "running")).to.have.length(0);
+  });
+  if (UDExLayout.collapsible) {
+    // Updated: mixed grouping also contains noncollapsible headers without this content wrapper.
+    UDExHeaderHost().filter("[collapsible]").each($header => {
+      cy.wrap($header).shadow().find(".udex-list__group-list__content").should($content => {
+        expect($content[0].getAnimations().filter(UDExAnimation =>
+          UDExAnimation.pending || UDExAnimation.playState === "running")).to.have.length(0);
+      });
+    });
+  }
+  UDExListHost().find("[_active-descendant]").should("have.length", 1);
+  UDExCombobox().should("be.focused");
+
+  // Post-click focus alone would miss a blur followed by a programmatic refocus.
+  UDExCombobox().then($input => {
+    $input[0].addEventListener("blur", cy.stub().as("comboboxBlur"));
+  });
+}
+
+function UDExAssertPresentationItem(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>) {
+  UDExHost.shadow().should($shadow => {
+    const $item = $shadow.find('[part="item"]');
+    expect($item).to.have.length(1);
+    expect($item).to.have.attr("role", "presentation");
+    UDExInnerStateAttributes.forEach(UDExAttribute => {
+      expect($item, `presentational row omits ${UDExAttribute}`).not.to.have.attr(UDExAttribute);
+    });
+    expect($shadow.find('[role="treeitem"], [role="option"], [role="listitem"]')).to.have.length(0);
+  });
+}
+
+function UDExAssertActiveDescendant(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>) {
+  // Updated: consume the queued host first and verify IDREF identity, not just matching strings.
+  UDExHost.should($host => {
+    expect($host).to.have.length(1);
+    expect($host).to.have.attr("_active-descendant");
+    expect($host).to.have.class("_udex-active-descendant");
+  }).and("not.be.focused").then($host => {
+    UDExListHost().find("[_active-descendant]").should("have.length", 1).and($active => {
+      expect($active[0]).to.equal($host[0]);
+    });
+    UDExListHost().find("._udex-active-descendant").should("have.length", 1).and($highlight => {
+      expect($highlight[0]).to.equal($host[0]);
+    });
+    UDExCombobox().should($input => {
+      const UDExRoot = $input[0].getRootNode() as ShadowRoot;
+      const UDExId = $input.attr("aria-activedescendant");
+      expect(UDExId).to.equal($host[0].id).and.not.to.equal("");
+      expect(UDExRoot.getElementById(UDExId!), "IDREF resolves to the rendered dropdown host, not a selected tag")
+        .to.equal($host[0]);
+      const UDExMatches = Array.from(UDExRoot.querySelectorAll("[id]")).filter(UDExElement => UDExElement.id === UDExId);
+      expect(UDExMatches, "exactly one element in the input's own shadow root owns the active ID").to.deep.equal([$host[0]]);
+    });
+  });
+  UDExCombobox().should("be.focused").should($input => {
+    const UDExRoot = $input[0].getRootNode() as ShadowRoot;
+    expect($input[0].ownerDocument.activeElement).to.equal(UDExRoot.host);
+    expect(UDExRoot.activeElement).to.equal($input[0]);
+  });
+}
+
+function UDExAssertSelectionEvent(UDExLabel: string, UDExSelectedLabels: string[], UDExCallCount = 1) {
+  cy.get("@selectionChange").should("have.callCount", UDExCallCount)
+    .its("lastCall.args.0.detail").should((UDExDetail: UDExSearchableListBaseSelectionChangeEventDetail) => {
+      expect(UDExDetail.item?.label).to.equal(UDExLabel);
+      expect(UDExDetail.selectedItems.filter(UDExItem => !UDExItem.isGroup).map(UDExItem => UDExItem.label))
+        .to.deep.equal(UDExSelectedLabels);
+    });
+}
+
+function UDExAssertSupplementalStatus(UDExExpected: string) {
+  UDExStatus().should($status => {
+    expect($status).to.have.length(1);
+    expect($status.text()).to.equal(UDExExpected);
+    // Navigation never repeats native names; explicit selection feedback is tested separately.
+    const UDExSelectBox = ($status[0].getRootNode() as ShadowRoot).host;
+    UDExSelectBox.querySelectorAll("[udex-select-box-item], [udex-select-box-group-header], [udex-select-box-select-all]").forEach(UDExItem => {
+      ["label", "supporting-text", "additional-text"].forEach(UDExAttribute => {
+        const UDExName = UDExItem.getAttribute(UDExAttribute);
+        if (UDExName) {
+          expect($status.text(), `status excludes ${UDExAttribute}: ${UDExName}`).not.to.contain(UDExName);
+        }
+      });
+    });
+  });
+}
+
+function UDExAssertSelectionStatus(UDExName: string, UDExState: "Selected" | "Unselected" | "Indeterminate") {
+  UDExStatus().should("have.length", 1).and("have.attr", "aria-atomic", "true");
+  UDExStatus().should("have.text", `${UDExName}, ${UDExState}`);
+}
+
+// Callers specify the opening status independently of rendered attributes.
+// Expanded active headers supply native feedback; other hosts need the popup fallback.
+function UDExAssertOpeningStatus(UDExExpected: "" | "expanded" = "expanded") {
+  // An empty expectation must not pass against the initial blank span before live text renders.
+  cy.then(() => renderFinished());
+  cy.get("[udex-select-box]").shadow().find("[aria-live]").should("have.length", 1).and("have.attr", "aria-live", "polite");
+  UDExAssertSupplementalStatus(UDExExpected);
+  UDExStatus().should("have.attr", "aria-atomic", "true");
+}
+
+function UDExAssertOpenWithActiveDescendant(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExExpectedStatus: "" | "expanded" = "expanded") {
+  // Consume the queued host query before unrelated queries change Cypress's subject.
+  UDExAssertActiveDescendant(UDExHost);
+  UDExAssertOpeningStatus(UDExExpectedStatus);
+  UDExPopover().should("have.attr", "open");
+  UDExCombobox().should("have.attr", "aria-expanded", "true");
+}
+
+function UDExAssertDescription(UDExExpected: string, UDExTokenCount?: number) {
+  UDExCombobox().should($input => {
+    const UDExIds = $input.attr("aria-describedby")!.split(/\s+/);
+    const UDExRoot = $input[0].getRootNode() as ShadowRoot;
+    expect(UDExIds).to.have.length(1);
+    const UDExDescription = UDExRoot.getElementById(UDExIds[0]);
+    expect(UDExDescription, "description resolves in the input's own shadow root").not.to.equal(null);
+    const UDExText = UDExTokenCount === undefined ? UDExExpected
+      : [UDExExpected, getTokensCountText(UDExTokenCount)].filter(Boolean).join(" ");
+    expect(UDExDescription!.textContent).to.equal(UDExText);
+  });
+}
+
+function UDExAssertSupplementalActiveDescendant(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExExpected: string) {
+  UDExAssertActiveDescendant(UDExHost);
+  UDExAssertSupplementalStatus(UDExExpected);
+}
+
+function UDExAssertHostPosition(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExPosition: number, UDExSize: number, UDExLevel?: number) {
+  UDExHost.should($host => {
+    expect($host).to.have.length(1);
+    expect($host).to.have.attr("role", UDExLevel === undefined ? "option" : "treeitem");
+    expect($host).to.have.attr("aria-posinset", String(UDExPosition));
+    expect($host).to.have.attr("aria-setsize", String(UDExSize));
+    if (UDExLevel === undefined) {
+      expect($host).not.to.have.attr("aria-level");
+    } else {
+      expect($host).to.have.attr("aria-level", String(UDExLevel));
+    }
+  });
+}
+
+function UDExAssertNativeActiveDescendant(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExPosition: number, UDExSize: number, UDExLevel?: number) {
+  // Consume the host before enqueueing any other queries, preserving exact IDREF ownership checks.
+  UDExHost.then($host => {
+    UDExAssertActiveDescendant(cy.wrap($host));
+    UDExAssertHostPosition(cy.wrap($host), UDExPosition, UDExSize, UDExLevel);
+  });
+  UDExAssertSupplementalStatus("");
+}
+
+function UDExAssertHostSelection(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExSelected: boolean,
+  UDExIndeterminate = false, UDExPartialDescription = "Indeterminate") {
+  UDExHost.should($host => {
+    expect($host).to.have.length(1);
+    expect($host).to.have.attr("aria-selected", String(UDExSelected && !UDExIndeterminate));
+    expect($host).not.to.have.attr("aria-checked");
+    if (UDExIndeterminate) {
+      expect($host).to.have.attr("aria-description", UDExPartialDescription);
+    } else {
+      expect($host).not.to.have.attr("aria-description");
+    }
+  });
+}
+
+function UDExAssertNativeHostStates() {
+  UDExListHost().find("[udex-list-item], [udex-list-group-header], [udex-list-select-all]").should($hosts => {
+    expect($hosts.length).to.be.greaterThan(0);
+    $hosts.each((UDExIndex, UDExHost) => {
+      expect(UDExHost).not.to.have.attr("aria-checked");
+      // Default-valued UI5 properties need not serialize an attribute.
+      if ((UDExHost as HTMLElement & { mode: string }).mode === UDExListMode.SingleContent) {
+        expect(UDExHost).not.to.have.attr("aria-selected");
+      } else {
+        expect(UDExHost.getAttribute("aria-selected"), `host ${UDExIndex} has Boolean selection`).to.be.oneOf(["true", "false"]);
+      }
+    });
+  });
+}
+
+function UDExAssertLeafName(UDExHost: Cypress.Chainable<JQuery<HTMLElement>>, UDExLabel: string, UDExSupportingText = "", UDExAdditionalText = "") {
+  // Active-descendant hosts expose the complete name, including text outside the title.
+  UDExHost.should("have.attr", "aria-label", [UDExLabel, UDExSupportingText, UDExAdditionalText].filter(Boolean).join(" "));
+  // Keep the rendered title/name-source checks, including after search highlighting.
+  UDExHost.shadow().find(".udex-list__content-wrap").should($content => {
+    expect($content).to.have.attr("aria-label", UDExLabel);
+    const UDExLabelId = $content.attr("aria-labelledby")!;
+    const UDExRoot = $content[0].getRootNode() as ShadowRoot;
+    expect(UDExRoot.getElementById(UDExLabelId)?.textContent).to.equal(UDExLabel);
+    expect($content.find('[part="title"]').text()).to.equal(UDExLabel);
+  });
+}
+
+const UDExCountryGroups = [
+  { label: "Europe", supportingText: "Available countries", countries: ["Germany", "France", "Spain"] },
+  { label: "Asia", supportingText: "More destinations", countries: ["Japan", "Jordan", "China"] },
+];
+
+function UDExMountCountrySelectBox() {
+  cy.mount(
+    <div id="select-box-regression-fixture">
+      <UDExSelectBox label="Country">
+        {UDExCountryGroups.map(UDExGroup => (
+          <UDExSelectBoxGroupHeader label={UDExGroup.label} supportingText={UDExGroup.supportingText} collapsible>
+            {UDExGroup.countries.map(UDExCountry => <UDExSelectBoxItem label={UDExCountry}></UDExSelectBoxItem>)}
+          </UDExSelectBoxGroupHeader>
+        ))}
+      </UDExSelectBox>
+    </div>
+  );
+  UDExOpenSelectBox(UDExLayouts[2]);
+  // Updated: the first country group is already expanded and owns its native state.
+  UDExAssertOpeningStatus("");
+}
+
+function UDExMountSelectAll(UDExLabel?: string, UDExSupportingText?: string, UDExDisabledChild = false) {
+  cy.mount(
+    <div id="select-box-regression-fixture">
+      <UDExSelectBox accessibleName="Languages" supportingText="Choose languages" mode={UDExListMode.MultiSelect}>
+        <UDExSelectBoxItem label="Worldwide"></UDExSelectBoxItem>
+        <UDExSelectBoxSelectAll id="select-all-source" label={UDExLabel} supportingText={UDExSupportingText}>
+          <UDExSelectBoxItem label="Alpha" supportingText="First choice" additionalText="Code A"></UDExSelectBoxItem>
+          <UDExSelectBoxItem label="Beta" supportingText="Second choice" additionalText="Code B"></UDExSelectBoxItem>
+          {UDExDisabledChild && <UDExSelectBoxItem label="Unavailable" disabled></UDExSelectBoxItem>}
+        </UDExSelectBoxSelectAll>
+        <UDExSelectBoxItem label="Other languages"></UDExSelectBoxItem>
+      </UDExSelectBox>
+    </div>
+  );
+  UDExOpenSelectBox(UDExLayouts[1]);
+  UDExAssertOpenWithActiveDescendant(UDExLeafHost("Worldwide"));
+  UDExAssertHostPosition(UDExLeafHost("Worldwide"), 1, 3, 1);
+  cy.get("#select-box-regression-fixture").then($fixture => {
+    $fixture[0].addEventListener("select-all", cy.stub().as("selectAll"));
+  });
+  UDExSelectAllHost().then($host => {
+    $host[0].addEventListener("ui5-select-all", cy.stub().as("routedSelectAll"));
+    $host[0].addEventListener("ui5-header-press", cy.stub().as("wrongHeaderPress"));
+  });
+}
+
+function UDExAssertSelectAllEvent(UDExCallCount: number) {
+  cy.get("@selectAll").should("have.callCount", UDExCallCount)
+    .its("lastCall.args.0").should((UDExEvent: Event) => {
+      expect(UDExEvent.type).to.equal("select-all");
+      expect(UDExEvent.bubbles).to.equal(true);
+    });
+  UDExSelectAllHost().then($host => {
+    cy.get("@routedSelectAll").should("have.callCount", UDExCallCount)
+      .its("lastCall.args.0.detail.item").should("equal", $host[0]);
+  });
+  cy.get("@wrongHeaderPress").should("not.have.been.called");
+  // Select All has its own public event; individual leaves retain selection-change payloads.
+  cy.get("@selectionChange").should("not.have.been.called");
+}
+
+describe("SelectBase resolved popup names", () => {
+  const UDExNameCases: {
+    name: string;
+    label?: string;
+    accessibleName?: string;
+    accessibleNameRef?: string;
+    expected: string;
+  }[] = [
+    { name: "accessibleName only", accessibleName: "Accessible languages", expected: "Accessible languages" },
+    { name: "accessibleName before visible label", label: "Languages", accessibleName: "Accessible languages", expected: "Accessible languages" },
+    { name: "external reference before accessibleName and label", label: "Languages", accessibleName: "Accessible languages", accessibleNameRef: "popup-name", expected: "Referenced languages" },
+    { name: "multiple external references in IDREF order", label: "Languages", accessibleName: "Accessible languages", accessibleNameRef: "popup-region popup-name", expected: "Regional Referenced languages" },
+    { name: "visible label fallback", label: "Languages", expected: "Languages" },
+    { name: "existing translated default", expected: "Select country" },
+  ];
+
+  [
+    { component: UDExSelectBox, tag: "[udex-select-box]", name: "SelectBox" },
+    { component: UDExCountrySelector, tag: "[udex-country-selector]", name: "CountrySelector" },
+  ].forEach(({ component: UDExComponent, tag: UDExTag, name: UDExName }) => {
+    const UDExInput = () => cy.get(UDExTag).shadow().find('input[role="combobox"]');
+    const UDExPopupList = () => cy.get(UDExTag).shadow().find("[udex-list]");
+
+    function UDExMountNamedPopup(UDExLabel?: string, UDExAccessibleName?: string, UDExNameRef?: string) {
+      cy.mount(
+        <div>
+          <span id="popup-name">Referenced languages</span>
+          <span id="popup-region">Regional</span>
+          <UDExComponent label={UDExLabel} accessibleName={UDExAccessibleName} accessibleNameRef={UDExNameRef}>
+            {UDExTag === "[udex-select-box]" && <UDExSelectBoxItem label="Alpha"></UDExSelectBoxItem>}
+          </UDExComponent>
+        </div>
+      );
+      // Install before opening: an eventual refocus must not hide a transient blur.
+      UDExInput().then($input => {
+        $input[0].addEventListener("blur", cy.stub().as("namedPopupBlur"));
+      });
+      UDExInput().realClick();
+      cy.get(UDExTag).shadow().find("[ui5-popover]").should("have.attr", "open");
+      UDExPopupList().find("[_active-descendant]").should("have.length", 1).then($active => {
+        UDExInput().should("have.attr", "aria-activedescendant", $active[0].id);
+      });
+      UDExInput().should("be.focused").should($input => {
+        const UDExRoot = $input[0].getRootNode() as ShadowRoot;
+        expect($input[0].ownerDocument.activeElement).to.equal(UDExRoot.host);
+        expect(UDExRoot.activeElement).to.equal($input[0]);
+      });
+      cy.get("@namedPopupBlur").should("not.have.been.called");
+    }
+
+    function UDExAssertPopupName(UDExExpected: string) {
+      UDExInput().should("have.attr", "aria-label", UDExExpected);
+      UDExInput().should("have.attr", "aria-haspopup", "listbox");
+      UDExPopupList().should($list => {
+        expect($list).to.have.attr("role", "listbox");
+        expect($list).to.have.attr("aria-label", UDExExpected);
+        expect($list).not.to.have.attr("aria-labelledby");
+        expect($list[0]).to.have.property("accessibleName", UDExExpected);
+      }).then($list => {
+        UDExInput().should("have.attr", "aria-controls", $list[0].id);
+      });
+      // CountrySelector's synthetic sources must remain safe in the shared tree-detection path.
+      UDExPopupList().find("[udex-list-item]").first().should("have.attr", "role", "option");
+    }
+
+    UDExNameCases.forEach(UDExCase => {
+      it(`${UDExName} uses the exact resolved name on the input and popup host for ${UDExCase.name}`, () => {
+        UDExMountNamedPopup(UDExCase.label, UDExCase.accessibleName, UDExCase.accessibleNameRef);
+        UDExAssertPopupName(UDExCase.expected);
+        cy.get("@namedPopupBlur").should("not.have.been.called");
+      });
+    });
+
+    it(`${UDExName} updates both host and input names when the visible label changes or is cleared`, () => {
+      UDExMountNamedPopup("Languages");
+      UDExAssertPopupName("Languages");
+      cy.get(UDExTag).invoke("prop", "label", "Updated languages");
+      UDExAssertPopupName("Updated languages");
+      cy.get(UDExTag).shadow().find('label[for="search-input"]').should("have.text", "Updated languages");
+      cy.get(UDExTag).invoke("prop", "label", "");
+      UDExAssertPopupName("Select country");
+      UDExInput().should("be.focused");
+      cy.get("@namedPopupBlur").should("not.have.been.called");
+    });
+  });
+});
+
+describe("SelectBox MultiSelect first-ever opening announcements", () => {
+  UDExLayouts.forEach(UDExLayout => {
+    (["pointer", "keyboard"] as const).forEach(UDExActivation => {
+      // Updated: expanded groups use native state; flat and noncollapsible hosts retain the popup fallback.
+      it(`uses ${UDExLayout.collapsible ? "native expanded-group state with empty live status" : "the expanded popup fallback"} on the first ${UDExActivation} opening and reopening of ${UDExLayout.name} MultiSelect without changing input or active-host identity`, () => {
+        // Never warm up by opening and closing: the first interaction must exercise a fresh popup.
+        UDExMountClosedSelectBox(UDExListMode.MultiSelect, UDExLayout);
+        cy.get("#select-box-regression-fixture").then($fixture => {
+          $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+        });
+        UDExPopover().then($popover => {
+          $popover[0].addEventListener("ui5-open", cy.stub().as("firstMultiSelectOpened"));
+        });
+        cy.get("[udex-select-box]").then($host => {
+          $host[0].addEventListener("close", cy.stub().as("firstMultiSelectClosed"));
+        });
+        UDExCombobox().then($input => {
+          const UDExOriginalInput = $input[0];
+          UDExOriginalInput.addEventListener("blur", cy.stub().as("comboboxBlur"));
+          const UDExAssertUnchangedInput = () => {
+            UDExCombobox().should($current => {
+              expect($current[0], "the original native input survives opening and selection").to.equal(UDExOriginalInput);
+            });
+            cy.get("@comboboxBlur").should("not.have.been.called");
+          };
+          const UDExNextLabel = UDExLayout.grouped ? "Alpha" : "Beta";
+
+          [1, 2].forEach(UDExCycle => {
+            UDExPopover().should("not.have.attr", "open");
+            UDExCombobox().should("have.attr", "aria-expanded", "false");
+            UDExCombobox().should("not.have.attr", "aria-activedescendant");
+            UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+            UDExAssertSupplementalStatus("");
+
+            if (UDExActivation === "pointer") {
+              UDExCombobox().realClick();
+            } else {
+              UDExCombobox().focus().realPress("ArrowDown");
+            }
+            cy.get("@firstMultiSelectOpened").should("have.callCount", UDExCycle);
+            UDExAssertOpenWithActiveDescendant(UDExLayout.grouped ? UDExHeaderHost() : UDExLeafHost("Alpha"),
+              UDExLayout.collapsible ? "" : "expanded");
+            UDExAssertHostPosition(UDExLayout.grouped ? UDExHeaderHost() : UDExLeafHost("Alpha"), 1,
+              UDExLayout.grouped ? 1 : 3, UDExLayout.grouped ? 1 : undefined);
+            if (UDExLayout.grouped) {
+              // Assert native state separately: it must not determine the expected live text.
+              UDExHeaderHost().should($header => {
+                if (UDExLayout.collapsible) {
+                  expect($header).to.have.attr("aria-expanded", "true");
+                } else {
+                  expect($header).not.to.have.attr("aria-expanded");
+                }
+              });
+              UDExAssertHostSelection(UDExHeaderHost(), false);
+            }
+            UDExAssertUnchangedInput();
+            cy.get("@selectionChange").should("have.callCount", (UDExCycle - 1) * 2);
+
+            // Opening already activated the first host: this must advance, not activate it again.
+            cy.realPress("ArrowDown");
+            UDExAssertNativeActiveDescendant(UDExLeafHost(UDExNextLabel), UDExLayout.grouped ? 1 : 2, 3,
+              UDExLayout.grouped ? 2 : undefined);
+            UDExAssertHostSelection(UDExLeafHost(UDExNextLabel), false);
+            UDExAssertUnchangedInput();
+
+            UDExLeafHost(UDExNextLabel).then($leaf => {
+              [true, false].forEach((UDExSelected, UDExIndex) => {
+                cy.realPress(UDExSelected ? "Enter" : "Space");
+                UDExSourceLeaf(UDExNextLabel).should(UDExSelected ? "have.attr" : "not.have.attr", "selected");
+                UDExAssertHostSelection(UDExLeafHost(UDExNextLabel), UDExSelected);
+                UDExAssertActiveDescendant(UDExLeafHost(UDExNextLabel));
+                UDExLeafHost(UDExNextLabel).should($current => {
+                  expect($current[0], "selection preserves the rendered active host").to.equal($leaf[0]);
+                });
+                UDExAssertSelectionStatus(UDExNextLabel, UDExSelected ? "Selected" : "Unselected");
+                UDExAssertSelectionEvent(UDExNextLabel, UDExSelected ? [UDExNextLabel] : [], (UDExCycle - 1) * 2 + UDExIndex + 1);
+                UDExPopover().should("have.attr", "open");
+                UDExCombobox().should("have.attr", "aria-expanded", "true");
+                UDExAssertUnchangedInput();
+              });
+            });
+
+            cy.realPress("Escape");
+            cy.get("@firstMultiSelectClosed").should("have.callCount", UDExCycle);
+            UDExPopover().should("not.have.attr", "open");
+            UDExCombobox().should("be.focused").and("have.attr", "aria-expanded", "false");
+            UDExCombobox().should("not.have.attr", "aria-activedescendant");
+            UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+            UDExAssertSupplementalStatus("");
+            UDExAssertUnchangedInput();
+          });
+        });
+      });
+    });
+  });
+});
+
+describe("SelectBox rating option accessibility", () => {
+  // These are DOM/interaction regressions, not assertions about JAWS speech.
+  type UDExRatingOption = {
+    rating: string;
+    ratingCount: string;
+    totalCount: string;
+    name: string;
+    ratingMax?: number;
+    label?: string;
+    supportingText?: string;
+    additionalText?: string;
+  };
+  const UDExRatings: UDExRatingOption[] = [
+    { rating: "5", ratingCount: "5.0", totalCount: "23", name: "Rating 5.0, Total 23, Rating Indicator 5 of 5" },
+    { rating: "4", ratingCount: "4.0", totalCount: "17", name: "Rating 4.0, Total 17, Rating Indicator 4 of 5" },
+    { rating: "3", ratingCount: "3.0", totalCount: "34", name: "Rating 3.0, Total 34, Rating Indicator 3 of 5" },
+    { rating: "2", ratingCount: "2.0", totalCount: "40", name: "Rating 2.0, Total 40, Rating Indicator 2 of 5" },
+    { rating: "1", ratingCount: "1.0", totalCount: "73", name: "Rating 1.0, Total 73, Rating Indicator 1 of 5" },
+  ];
+  const UDExRatingHost = (UDExIndex: number) => UDExListHost().find("[udex-list-item]").eq(UDExIndex);
+  const UDExRatingSource = (UDExIndex: number) => cy.get("[udex-select-box]").find("[udex-select-box-item]").eq(UDExIndex);
+  const UDExRatingTags = () => cy.get("[udex-select-box]").shadow().find("[udex-tag-group]").shadow().find("[udex-tag]");
+
+  function UDExMountRatings(UDExMode: UDExSelectBoxMode = UDExListMode.MultiSelect,
+    UDExActivation: "pointer" | "keyboard" = "pointer", UDExOptions = UDExRatings) {
+    cy.mount(
+      <div id="select-box-regression-fixture">
+        <UDExSelectBox label="Rating" mode={UDExMode}>
+          {UDExOptions.map(UDExOption => (
+            <UDExSelectBoxItem label={UDExOption.label} supportingText={UDExOption.supportingText}
+              additionalText={UDExOption.additionalText} rating={UDExOption.rating}
+              ratingCount={UDExOption.ratingCount} totalCount={UDExOption.totalCount}
+              ratingMax={UDExOption.ratingMax ?? 5}></UDExSelectBoxItem>
+          ))}
+        </UDExSelectBox>
+      </div>
+    );
+    // Install before the very first opening to catch even a transient blur/refocus.
+    UDExCombobox().then($input => {
+      cy.wrap($input).as("ratingOriginalInput", { type: "static" });
+      $input[0].addEventListener("blur", cy.stub().as("ratingInputBlur"));
+    });
+    UDExPopover().should("not.have.attr", "open");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    if (UDExActivation === "pointer") {
+      UDExOpenSelectBox(UDExLayouts[0]);
+    } else {
+      cy.get("#select-box-regression-fixture").then($fixture => {
+        $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+      });
+      UDExCombobox().focus().realPress("ArrowDown");
+    }
+    UDExAssertOpenWithActiveDescendant(UDExRatingHost(0), "expanded");
+    UDExAssertRatingInput();
+  }
+
+  function UDExAssertRatingInput() {
+    cy.get<JQuery<HTMLElement>>("@ratingOriginalInput").then($original => {
+      UDExCombobox().should("be.focused").should($current => {
+        expect($current[0], "the original native input is retained").to.equal($original[0]);
+        ["aria-description", "aria-roledescription", "aria-keyshortcuts"].forEach(UDExAttribute => {
+          expect($current, "no added navigation metadata").not.to.have.attr(UDExAttribute);
+        });
+      });
+    });
+    cy.get("@ratingInputBlur").should("not.have.been.called");
+  }
+
+  function UDExAssertRatingName(UDExIndex: number, UDExName: string) {
+    UDExRatingHost(UDExIndex).should($host => {
+      expect($host).to.have.attr("aria-label", UDExName);
+      expect($host.attr("aria-label")).not.to.match(/checkbox|selected|unselected/i);
+      ["aria-checked", "aria-description", "aria-roledescription", "aria-keyshortcuts"].forEach(UDExAttribute => {
+        expect($host).not.to.have.attr(UDExAttribute);
+      });
+    });
+    UDExAssertPresentationItem(UDExRatingHost(UDExIndex));
+  }
+
+  function UDExAssertRatingCheckbox(UDExIndex: number, UDExSelected: boolean) {
+    UDExRatingHost(UDExIndex).shadow().find("[udex-checkbox]").should($checkbox => {
+      expect($checkbox).to.have.length(1);
+      expect($checkbox).to.have.attr("aria-hidden", "true");
+      expect($checkbox).to.have.attr("tabindex", "-1");
+      expect($checkbox[0]).to.have.property("checked", UDExSelected);
+      // UI5 may reflect an omitted name as accessible-name=""; absence is not the contract.
+      expect($checkbox.prop("accessibleName") || "").not.to.match(/checkbox|selected|unselected/i);
+      expect($checkbox.attr("accessible-name") || "").not.to.match(/checkbox|selected|unselected/i);
+    });
+  }
+
+  function UDExAssertRatingVisual(UDExIndex: number, UDExOption: UDExRatingOption) {
+    UDExRatingHost(UDExIndex).shadow().find("[udex-rating-indicator]").should($rating => {
+      expect($rating).to.have.length(1);
+      expect($rating[0]).to.have.property("value", Number(UDExOption.rating));
+      expect($rating[0]).to.have.property("max", UDExOption.ratingMax ?? 5);
+      expect($rating).to.have.attr("rating-count", UDExOption.ratingCount);
+      expect($rating).to.have.attr("total-count", UDExOption.totalCount);
+      expect($rating).to.have.attr("disabled");
+      expect($rating).to.have.attr("readonly");
+    });
+  }
+
+  function UDExAssertRatingEvent(UDExSource: UDExSelectBoxItemElement, UDExSelected: boolean, UDExCallCount: number) {
+    cy.get("@selectionChange").should("have.callCount", UDExCallCount).its("lastCall.args.0")
+      .should((UDExEvent: CustomEvent<UDExSearchableListBaseSelectionChangeEventDetail>) => {
+        expect(UDExEvent.type).to.equal("selection-change");
+        expect(UDExEvent.bubbles).to.equal(true);
+        expect(UDExEvent.detail.item, "payload uses the original source, not a rendered copy").to.equal(UDExSource);
+        expect(UDExEvent.detail.selectedItems).to.have.length(UDExSelected ? 1 : 0);
+        if (UDExSelected) {
+          expect(UDExEvent.detail.selectedItems[0]).to.equal(UDExSource);
+        }
+      });
+  }
+
+  function UDExToggleRating(UDExActivation: "pointer" | "Enter" | "Space", UDExSelected: boolean, UDExCallCount: number) {
+    UDExRatingSource(0).then($source => {
+      const UDExOriginalSource = $source[0] as UDExSelectBoxItemElement;
+      UDExRatingHost(0).then($host => {
+        if (UDExActivation === "pointer") {
+          UDExRatingHost(0).shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+        } else {
+          cy.realPress(UDExActivation);
+        }
+        UDExRatingSource(0).should($current => {
+          expect($current[0]).to.equal(UDExOriginalSource);
+          expect($current[0]).to.have.property("selected", UDExSelected);
+        });
+        UDExRatingHost(0).should($current => expect($current[0]).to.equal($host[0]));
+        UDExAssertHostSelection(UDExRatingHost(0), UDExSelected);
+        UDExAssertRatingName(0, UDExRatings[0].name);
+        UDExAssertRatingCheckbox(0, UDExSelected);
+        UDExAssertRatingVisual(0, UDExRatings[0]);
+        UDExAssertActiveDescendant(UDExRatingHost(0));
+        UDExAssertSelectionStatus(UDExRatings[0].name, UDExSelected ? "Selected" : "Unselected");
+        UDExAssertRatingEvent(UDExOriginalSource, UDExSelected, UDExCallCount);
+        if (UDExSelected) {
+          UDExRatingTags().should("have.length", 1).should($tags => {
+            expect($tags).to.have.attr("text", "5 stars");
+            expect($tags).to.have.attr("data-id", UDExOriginalSource._id);
+          });
+        } else {
+          cy.get("[udex-select-box]").shadow().find("[udex-tag-group]").should("not.exist");
+        }
+        UDExPopover().should("have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "true");
+        UDExAssertRatingInput();
+      });
+    });
+  }
+
+  (["pointer", "keyboard"] as const).forEach(UDExActivation => {
+    it(`exposes all five state-free rating names on the first ${UDExActivation} opening and advances immediately with ArrowDown`, () => {
+      UDExMountRatings(UDExListMode.MultiSelect, UDExActivation);
+      UDExCombobox().should("have.attr", "aria-label", "Rating").and("have.attr", "aria-haspopup", "listbox");
+      UDExListHost().should("have.attr", "role", "listbox").and("have.attr", "aria-multiselectable", "true");
+      UDExListHost().find("[udex-list-item]").should("have.length", 5);
+      UDExRatings.forEach((UDExOption, UDExIndex) => {
+        UDExAssertRatingName(UDExIndex, UDExOption.name);
+        UDExAssertHostPosition(UDExRatingHost(UDExIndex), UDExIndex + 1, 5);
+        UDExAssertHostSelection(UDExRatingHost(UDExIndex), false);
+        UDExAssertRatingCheckbox(UDExIndex, false);
+        UDExAssertRatingVisual(UDExIndex, UDExOption);
+      });
+      UDExAssertActiveDescendant(UDExRatingHost(0));
+      cy.get("[udex-select-box]").shadow().find('[aria-live], [role="status"], [role="alert"]').should("have.length", 1);
+      cy.realPress("ArrowDown");
+      UDExAssertNativeActiveDescendant(UDExRatingHost(1), 2, 5);
+      UDExAssertRatingName(1, UDExRatings[1].name);
+      UDExAssertRatingInput();
+      cy.get("@selectionChange").should("not.have.been.called");
+    });
+  });
+
+  (["Enter", "Space", "pointer"] as const).forEach(UDExActivation => {
+    it(`toggles a rating false to true to false with ${UDExActivation}, retaining one native state owner, source identity and full-name feedback`, () => {
+      UDExMountRatings();
+      UDExAssertHostSelection(UDExRatingHost(0), false);
+      UDExAssertRatingCheckbox(0, false);
+      UDExToggleRating(UDExActivation, true, 1);
+      UDExToggleRating(UDExActivation, false, 2);
+      cy.realPress("ArrowDown");
+      UDExAssertNativeActiveDescendant(UDExRatingHost(1), 2, 5);
+      UDExAssertRatingInput();
+    });
+  });
+
+  it("maps an unlabelled rating tag's delete icon back to the exact source without changing the other selected rating", () => {
+    UDExMountRatings();
+    UDExToggleRating("Enter", true, 1);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExRatingHost(1), 2, 5);
+    UDExRatingSource(0).then($first => {
+      UDExRatingSource(1).then($second => {
+        cy.realPress("Space");
+        cy.get("@selectionChange").should("have.callCount", 2).its("lastCall.args.0.detail")
+          .should((UDExDetail: UDExSearchableListBaseSelectionChangeEventDetail) => {
+            expect(UDExDetail.item).to.equal($second[0]);
+            expect(UDExDetail.selectedItems).to.have.length(2);
+            expect(UDExDetail.selectedItems[0]).to.equal($first[0]);
+            expect(UDExDetail.selectedItems[1]).to.equal($second[0]);
+          });
+      });
+    });
+    UDExAssertHostSelection(UDExRatingHost(1), true);
+    UDExAssertRatingCheckbox(1, true);
+    UDExAssertSelectionStatus(UDExRatings[1].name, "Selected");
+    UDExRatingTags().should("have.length", 2);
+    UDExAssertActiveDescendant(UDExRatingHost(1));
+    UDExPopover().should("have.attr", "open");
+    UDExAssertRatingInput();
+    cy.get("#select-box-regression-fixture").then($fixture => {
+      $fixture[0].addEventListener("remove", cy.stub().as("ratingTagRemoved"));
+    });
+    UDExRatingSource(0).then($source => {
+      const UDExOriginalSource = $source[0] as UDExSelectBoxItemElement;
+      UDExRatingSource(1).then($second => {
+        UDExRatingTags().filter('[text="5 stars"]').should("have.attr", "data-id", UDExOriginalSource._id);
+        UDExRatingTags().filter('[text="5 stars"]').shadow().find('[ui5-icon][name="decline"]').click();
+        cy.get("@ratingTagRemoved").should("have.been.calledOnce").its("lastCall.args.0")
+          .should((UDExEvent: CustomEvent<UDExSelectBoxRemoveEventDetail>) => {
+            expect(UDExEvent.bubbles).to.equal(true);
+            expect(UDExEvent.detail.item).to.equal(UDExOriginalSource);
+            expect(UDExEvent.detail.item).to.have.property("selected", false);
+          });
+        UDExRatingTags().should("have.length", 1).should($tag => {
+          expect($tag).to.have.attr("text", "4 stars");
+          expect($tag).to.have.attr("data-id", ($second[0] as UDExSelectBoxItemElement)._id);
+        });
+        UDExRatingSource(0).should($current => expect($current[0]).to.equal(UDExOriginalSource));
+        UDExRatingSource(1).should($current => {
+          expect($current[0]).to.equal($second[0]);
+          expect($current[0]).to.have.property("selected", true);
+        });
+      });
+    });
+    UDExAssertHostSelection(UDExRatingHost(0), false);
+    UDExAssertHostSelection(UDExRatingHost(1), true);
+    UDExAssertRatingCheckbox(0, false);
+    UDExAssertRatingCheckbox(1, true);
+    UDExAssertRatingName(0, UDExRatings[0].name);
+    UDExAssertRatingName(1, UDExRatings[1].name);
+    // Removal has its own public event; it does not add a selection-change event.
+    cy.get("@selectionChange").should("have.callCount", 2);
+    UDExCombobox().should("be.focused");
+    cy.get<JQuery<HTMLElement>>("@ratingOriginalInput").then($original => {
+      UDExCombobox().should($current => expect($current[0]).to.equal($original[0]));
+    });
+  });
+
+  it("preserves the complete source rating name in SingleSelect feedback after selection closes the popup", () => {
+    UDExMountRatings(UDExListMode.SingleSelect, "keyboard");
+    UDExRatingSource(0).then($source => {
+      const UDExOriginalSource = $source[0] as UDExSelectBoxItemElement;
+      // No rendered aria-label on the source: close feedback must use the shared base getter.
+      expect($source).not.to.have.attr("aria-label");
+      expect(UDExOriginalSource.ratingAriaLabel).to.equal(UDExRatings[0].name);
+      UDExAssertRatingName(0, UDExRatings[0].name);
+      UDExAssertHostSelection(UDExRatingHost(0), false);
+      cy.realPress("Enter");
+      UDExAssertRatingEvent(UDExOriginalSource, true, 1);
+      UDExRatingSource(0).should($current => {
+        expect($current[0]).to.equal(UDExOriginalSource);
+        expect($current[0]).to.have.property("selected", true);
+      });
+    });
+    UDExPopover().should("not.have.attr", "open");
+    UDExCombobox().should("have.attr", "aria-expanded", "false");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+    UDExAssertHostSelection(UDExRatingHost(0), true);
+    UDExAssertSelectionStatus(UDExRatings[0].name, "Selected");
+    UDExAssertRatingInput();
+  });
+
+  it("retains label, supporting text and additional text with zero rating/counts and a custom maximum", () => {
+    const UDExZeroRating: UDExRatingOption = {
+      rating: "0", ratingCount: "0", totalCount: "0", ratingMax: 7,
+      label: "Reviews", supportingText: "No reviews yet", additionalText: "Code R",
+      name: "Reviews No reviews yet Code R Rating 0, Total 0, Rating Indicator 0 of 7",
+    };
+    UDExMountRatings(UDExListMode.MultiSelect, "keyboard", [UDExZeroRating]);
+    UDExAssertRatingName(0, UDExZeroRating.name);
+    UDExAssertHostPosition(UDExRatingHost(0), 1, 1);
+    UDExAssertHostSelection(UDExRatingHost(0), false);
+    UDExAssertRatingCheckbox(0, false);
+    UDExAssertRatingVisual(0, UDExZeroRating);
+    cy.realPress("Enter");
+    UDExAssertRatingName(0, UDExZeroRating.name);
+    UDExAssertSelectionStatus(UDExZeroRating.name, "Selected");
+    UDExAssertHostSelection(UDExRatingHost(0), true);
+    UDExAssertRatingCheckbox(0, true);
+    UDExAssertActiveDescendant(UDExRatingHost(0));
+    UDExPopover().should("have.attr", "open");
+    UDExAssertRatingInput();
+  });
+
+  it("recalculates the active host's complete rating name after reactive source changes without stale state words", () => {
+    UDExMountRatings();
+    UDExToggleRating("Enter", true, 1);
+    // Clear explicit selection feedback through normal navigation before updating data.
+    cy.realPress("ArrowDown");
+    cy.realPress("ArrowUp");
+    UDExAssertNativeActiveDescendant(UDExRatingHost(0), 1, 5);
+    const UDExUpdated: UDExRatingOption = {
+      rating: "6", ratingCount: "6.0", totalCount: "99", ratingMax: 7,
+      name: "Rating 6.0, Total 99, Rating Indicator 6 of 7",
+    };
+    UDExRatingHost(0).then($host => {
+      UDExRatingSource(0).then($source => {
+        const UDExSource = $source[0] as UDExSelectBoxItemElement;
+        UDExSource.rating = UDExUpdated.rating;
+        UDExSource.ratingCount = UDExUpdated.ratingCount;
+        UDExSource.totalCount = UDExUpdated.totalCount;
+        UDExSource.ratingMax = UDExUpdated.ratingMax!;
+      });
+      UDExAssertRatingName(0, UDExUpdated.name);
+      UDExAssertRatingVisual(0, UDExUpdated);
+      UDExRatingHost(0).should($current => expect($current[0]).to.equal($host[0]));
+    });
+    UDExAssertHostSelection(UDExRatingHost(0), true);
+    UDExAssertRatingCheckbox(0, true);
+    UDExAssertNativeActiveDescendant(UDExRatingHost(0), 1, 5);
+    cy.get("@selectionChange").should("have.been.calledOnce");
+    UDExAssertRatingInput();
+  });
+});
+
+describe("SelectBox Country List first-ever opening announcements", () => {
+  const UDExStoryCountryGroups = [
+    {
+      label: "North America",
+      countries: [
+        { label: "United States", supportingText: "USA, United States of America" },
+        { label: "Canada", supportingText: "" },
+        { label: "Mexico", supportingText: "" },
+      ],
+    },
+    {
+      label: "Asia",
+      countries: ["India", "China", "Japan", "Singapore"].map(UDExLabel => ({ label: UDExLabel, supportingText: "" })),
+    },
+  ];
+
+  (["pointer", "keyboard"] as const).forEach(UDExActivation => {
+    it(`keeps live status empty on the very first ${UDExActivation} Country List opening and Escape reopening without duplicating native group information or moving focus`, () => {
+      // Match the Country List story's SingleSelect mode and two expanded collapsible groups.
+      // Mount closed: a prior warm-up opening would miss the reported first-interaction regression.
+      cy.mount(
+        <div id="select-box-regression-fixture">
+          <UDExSelectBox label="Countries" mode={UDExListMode.SingleSelect}>
+            {UDExStoryCountryGroups.map(UDExGroup => (
+              <UDExSelectBoxGroupHeader label={UDExGroup.label} collapsible>
+                {UDExGroup.countries.map(UDExCountry => (
+                  <UDExSelectBoxItem label={UDExCountry.label} supportingText={UDExCountry.supportingText}></UDExSelectBoxItem>
+                ))}
+              </UDExSelectBoxGroupHeader>
+            ))}
+          </UDExSelectBox>
+        </div>
+      );
+      cy.get("#select-box-regression-fixture").then($fixture => {
+        $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+      });
+      UDExPopover().then($popover => {
+        $popover[0].addEventListener("ui5-open", cy.stub().as("countryListOpened"));
+      });
+      cy.get("[udex-select-box]").then($host => {
+        $host[0].addEventListener("close", cy.stub().as("countryListClosed"));
+      });
+      UDExCombobox().then($input => {
+        const UDExOriginalInput = $input[0];
+        UDExOriginalInput.addEventListener("blur", cy.stub().as("countryListBlur"));
+        const UDExAssertUnchangedInput = (UDExExpectedDescription = "") => {
+          UDExCombobox().should("be.focused").should($current => {
+            expect($current[0], "the original native input survives opening, navigation and close").to.equal(UDExOriginalInput);
+            ["aria-description", "aria-roledescription", "aria-keyshortcuts"].forEach(UDExAttribute => {
+              expect($current, "no custom navigation instructions or duplicate state on the input").not.to.have.attr(UDExAttribute);
+            });
+            const UDExRoot = $current[0].getRootNode() as ShadowRoot;
+            expect($current[0].ownerDocument.activeElement).to.equal(UDExRoot.host);
+            expect(UDExRoot.activeElement).to.equal(UDExOriginalInput);
+          });
+          UDExAssertDescription(UDExExpectedDescription);
+          cy.get("@countryListBlur").should("not.have.been.called");
+          cy.get("@selectionChange").should("not.have.been.called");
+          cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+        };
+
+        [1, 2].forEach(UDExCycle => {
+          UDExPopover().should("not.have.attr", "open");
+          UDExCombobox().should("have.attr", "aria-expanded", "false");
+          UDExCombobox().should("not.have.attr", "aria-activedescendant");
+          UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+          UDExAssertSupplementalStatus("");
+
+          if (UDExActivation === "pointer") {
+            UDExCombobox().realClick();
+          } else {
+            UDExCombobox().focus().realPress("ArrowDown");
+          }
+          cy.get("@countryListOpened").should("have.callCount", UDExCycle);
+          UDExAssertOpenWithActiveDescendant(UDExHeaderHost().first(), "");
+          UDExCombobox().should("have.attr", "aria-label", "Countries");
+          UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+          UDExListHost().should("have.attr", "role", "tree");
+          UDExListHost().should("have.attr", "aria-label", "Countries");
+          UDExListHost().then($list => {
+            UDExCombobox().should("have.attr", "aria-controls", $list[0].id);
+          });
+          cy.get("[udex-select-box]").shadow().find('[aria-live], [role="status"], [role="alert"]')
+            .should("have.length", 1);
+          UDExHeaderHost().should("have.length", 2).each(($header, UDExIndex) => {
+            const UDExGroup = UDExStoryCountryGroups[UDExIndex];
+            UDExAssertHostPosition(cy.wrap($header), UDExIndex + 1, 2, 1);
+            UDExAssertHostSelection(cy.wrap($header), false);
+            cy.wrap($header).should($host => {
+              expect($host).to.have.attr("aria-label", UDExGroup.label);
+              expect($host).to.have.attr("aria-expanded", "true");
+              ["aria-description", "aria-describedby", "aria-roledescription", "aria-keyshortcuts"].forEach(UDExAttribute => {
+                expect($host, "native name, hierarchy and expansion need no custom instructions").not.to.have.attr(UDExAttribute);
+              });
+            });
+            cy.wrap($header).shadow().find('[part="group-item"]').should($row => {
+              expect($row).to.have.attr("role", "presentation");
+              [...UDExInnerStateAttributes, "aria-label", "aria-labelledby"].forEach(UDExAttribute => {
+                expect($row, "the inner group row does not duplicate host semantics").not.to.have.attr(UDExAttribute);
+              });
+            });
+            cy.wrap($header).shadow().find('[role="treeitem"], [role="option"], [aria-live]').should("not.exist");
+            cy.wrap($header).find("[udex-list-item]").should("have.length", UDExGroup.countries.length).each(($country, UDExCountryIndex) => {
+              const UDExCountry = UDExGroup.countries[UDExCountryIndex];
+              UDExAssertHostPosition(cy.wrap($country), UDExCountryIndex + 1, UDExGroup.countries.length, 2);
+              UDExAssertHostSelection(cy.wrap($country), false);
+              UDExAssertLeafName(cy.wrap($country), UDExCountry.label, UDExCountry.supportingText);
+              cy.wrap($country).should("not.have.attr", "aria-expanded");
+              UDExAssertPresentationItem(cy.wrap($country));
+            });
+          });
+          UDExAssertUnchangedInput();
+
+          UDExHeaderHost().first().then($group => {
+            UDExLeafHost("United States").then($country => {
+              // The opening already activates North America: the next key must advance immediately.
+              cy.realPress("ArrowDown");
+              UDExAssertNativeActiveDescendant(UDExLeafHost("United States"), 1, 3, 2);
+              UDExLeafHost("United States").should($current => expect($current[0]).to.equal($country[0]));
+              UDExAssertLeafName(UDExLeafHost("United States"), "United States", "USA, United States of America");
+              UDExAssertUnchangedInput();
+
+              cy.realPress("ArrowUp");
+              UDExAssertNativeActiveDescendant(UDExHeaderHost().first(), 1, 2, 1);
+              UDExHeaderHost().first().should($current => {
+                expect($current[0], "backward navigation returns to the original group host and ID owner").to.equal($group[0]);
+                expect($current).to.have.attr("aria-label", "North America");
+                expect($current).to.have.attr("aria-expanded", "true");
+              });
+              UDExAssertUnchangedInput();
+            });
+          });
+
+          cy.realPress("Escape");
+          cy.get("@countryListClosed").should("have.callCount", UDExCycle);
+          UDExPopover().should("not.have.attr", "open");
+          UDExCombobox().should("have.attr", "aria-expanded", "false");
+          UDExCombobox().should("not.have.attr", "aria-activedescendant");
+          UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+          UDExAssertSupplementalStatus("");
+          // SingleSelect retains its navigated value description once the active item is cleared.
+          UDExAssertUnchangedInput("North America");
+        });
+      });
+    });
+  });
+});
+
+describe("SelectBox close before pending opening activation", () => {
+  let UDExObserver: MutationObserver | undefined;
+
+  afterEach(() => UDExObserver?.disconnect());
+
+  it("does not activate or announce expanded after a synchronous close in the first open event", () => {
+    UDExMountClosedSelectBox(UDExListMode.MultiSelect, UDExLayouts[0]);
+    UDExCombobox().then($input => {
+      const UDExOriginalInput = $input[0];
+      const UDExRecords: MutationRecord[] = [];
+      UDExObserver = new MutationObserver(UDExChanges => UDExRecords.push(...UDExChanges));
+      UDExObserver.observe(UDExOriginalInput, {
+        attributes: true, attributeFilter: ["aria-activedescendant"], attributeOldValue: true,
+      });
+      UDExOriginalInput.addEventListener("blur", cy.stub().as("pendingOpeningBlur"));
+      cy.get("[udex-select-box]").then($host => {
+        const UDExSelectBox = $host[0] as UDExSelectBoxElement;
+        UDExSelectBox.addEventListener("close", cy.stub().as("pendingOpeningClosed"));
+        // The public open event fires synchronously after scheduling activation, before renderFinished settles.
+        // Close here rather than racing Escape against rendering or introducing a time-based wait.
+        UDExSelectBox.addEventListener("open", cy.stub().callsFake(() => {
+          expect(UDExOriginalInput.hasAttribute("aria-activedescendant"), "opening activation is still pending").to.equal(false);
+          UDExSelectBox.close();
+        }).as("pendingOpeningOpened"), { once: true });
+      });
+      UDExCombobox().focus().realPress("ArrowDown");
+      cy.get("@pendingOpeningOpened").should("have.been.calledOnce");
+      cy.get("@pendingOpeningClosed").should("have.been.calledOnce");
+      // Drain the same rendering stages as handleDropdownOpen, without arbitrary delays.
+      cy.then(() => renderFinished()).then(() => renderFinished());
+      UDExPopover().should("not.have.attr", "open");
+      UDExCombobox().should("be.focused").and("have.attr", "aria-expanded", "false");
+      UDExCombobox().should("not.have.attr", "aria-activedescendant");
+      UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+      UDExAssertSupplementalStatus("");
+      UDExCombobox().should($current => expect($current[0]).to.equal(UDExOriginalInput));
+      cy.get("@pendingOpeningBlur").should("not.have.been.called");
+      cy.then(() => {
+        UDExRecords.push(...UDExObserver!.takeRecords());
+        UDExObserver!.disconnect();
+        // Catch an activation that is subsequently cleared, not just a stale ID left after close.
+        UDExRecords.forEach(UDExRecord => expect(UDExRecord.oldValue, "no transient active ID after close").to.equal(null));
+        expect(UDExOriginalInput.hasAttribute("aria-activedescendant")).to.equal(false);
+      });
+    });
+  });
+});
+
+describe("SelectBox host-owned accessibility regressions", () => {
+  UDExModes.forEach(UDExMode => {
+    UDExLayouts.forEach(UDExLayout => {
+      describe(`${UDExMode} / ${UDExLayout.name}`, () => {
+        const UDExOwnerRole = UDExLayout.grouped ? "tree" : UDExMode === UDExListMode.SingleContent ? "list" : "listbox";
+        const UDExItemRole = UDExLayout.grouped ? "treeitem" : UDExMode === UDExListMode.SingleContent ? "listitem" : "option";
+
+        beforeEach(() => {
+          UDExMountSelectBox(UDExMode, UDExLayout);
+        });
+
+        // Updated: reopening omits live expansion for expanded headers; other initial hosts keep the fallback.
+        it("activates the first navigable item on each ArrowDown reopening, then advances without moving input focus", () => {
+          UDExPopover().then($popover => {
+            $popover[0].addEventListener("ui5-open", cy.stub().as("keyboardPopoverOpened"));
+          });
+          cy.get("[udex-select-box]").then($selectBox => {
+            $selectBox[0].addEventListener("close", cy.stub().as("keyboardDropdownClosed"));
+          });
+          const UDExStartsOnHeader = UDExLayout.grouped && (UDExLayout.collapsible || UDExMode === UDExListMode.MultiSelect);
+
+          [1, 2].forEach(UDExCycle => {
+            // The click-opened popup is closed first, so ArrowDown really exercises keyboard opening.
+            cy.realPress("Escape");
+            UDExPopover().should("not.have.attr", "open");
+            UDExCombobox().should("have.attr", "aria-expanded", "false");
+            UDExCombobox().should("not.have.attr", "aria-activedescendant");
+            UDExListHost().find("[_active-descendant]").should("not.exist");
+            UDExAssertSupplementalStatus("");
+            UDExCombobox().should("be.focused");
+            cy.get("@keyboardDropdownClosed").should("have.callCount", UDExCycle);
+
+            cy.realPress("ArrowDown");
+            cy.get("@keyboardPopoverOpened").should("have.callCount", UDExCycle);
+            UDExAssertOpenWithActiveDescendant(UDExStartsOnHeader ? UDExHeaderHost() : UDExLeafHost("Alpha"),
+              UDExLayout.collapsible ? "" : "expanded");
+            cy.get("@selectionChange").should("not.have.been.called");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+
+            UDExListHost().find("[_active-descendant]").should("have.length", 1).should($host => {
+              expect($host).to.have.attr("role", UDExItemRole);
+              expect($host).to.have.attr("aria-posinset", "1");
+              expect($host).to.have.attr("aria-setsize", UDExStartsOnHeader ? "1" : "3");
+              if (UDExLayout.grouped) {
+                expect($host).to.have.attr("aria-level", UDExStartsOnHeader ? "1" : "2");
+              } else {
+                expect($host).not.to.have.attr("aria-level");
+              }
+            });
+
+            cy.realPress("ArrowDown");
+            UDExAssertSupplementalActiveDescendant(UDExLeafHost(UDExStartsOnHeader ? "Alpha" : "Beta"), "");
+            UDExLeafHost(UDExStartsOnHeader ? "Alpha" : "Beta").should($host => {
+              expect($host).to.have.attr("aria-posinset", UDExStartsOnHeader ? "1" : "2");
+              expect($host).to.have.attr("aria-setsize", "3");
+              if (UDExMode === UDExListMode.SingleContent) {
+                expect($host).not.to.have.attr("aria-selected");
+              } else {
+                expect($host).to.have.attr("aria-selected", "false");
+              }
+              if (UDExLayout.grouped) {
+                expect($host).to.have.attr("aria-level", "2");
+              }
+            });
+
+            // Navigation clears live feedback; disabled leaves still contribute to native set size.
+            cy.realPress("End");
+            UDExAssertSupplementalActiveDescendant(UDExLeafHost("Beta"), "");
+            UDExLeafHost("Beta").should($host => {
+              expect($host).to.have.attr("aria-posinset", "2");
+              expect($host).to.have.attr("aria-setsize", "3");
+              if (UDExMode === UDExListMode.SingleContent) {
+                expect($host).not.to.have.attr("aria-selected");
+              } else {
+                expect($host).to.have.attr("aria-selected", "false");
+              }
+            });
+            UDExAssertNativeHostStates();
+            UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+            cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+            cy.get("@selectionChange").should("not.have.been.called");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+          });
+        });
+
+        // Updated: native hosts own names and Boolean selection, never checked state or duplicate inner widgets.
+        it("keeps the owning role, labels and states on hosts without duplicate inner widgets or tab stops", () => {
+          UDExCombobox().should("have.attr", "aria-label", "Languages");
+          UDExListHost().should($host => {
+            expect($host).to.have.attr("role", UDExOwnerRole);
+            expect($host).to.have.attr("accessible-role", "");
+            expect($host).to.have.attr("aria-label", "Languages");
+            expect($host[0]).to.have.property("accessibleName", "Languages");
+            if (UDExMode === UDExListMode.MultiSelect) {
+              expect($host).to.have.attr("aria-multiselectable", "true");
+            } else {
+              expect($host).not.to.have.attr("aria-multiselectable");
+            }
+          });
+          UDExListHost().then($host => {
+            UDExCombobox().should("have.attr", "aria-controls", $host[0].id);
+          });
+          UDExListHost().shadow().find("#udex-list").should($inner => {
+            expect($inner).to.have.attr("role", "none");
+            ["aria-label", "aria-labelledby", "aria-multiselectable", "aria-busy"].forEach(UDExAttribute => {
+              expect($inner, `inner container omits ${UDExAttribute}`).not.to.have.attr(UDExAttribute);
+            });
+          });
+          UDExListHost().shadow().find('[role="tree"], [role="listbox"], [role="list"], .udex-list__hidden-text')
+            .should("not.exist");
+
+          UDExListHost().find("[udex-list-item]").should("have.length", 3).each($item => {
+            cy.wrap($item).should($host => {
+              expect($host).to.have.attr("role", UDExItemRole);
+              expect($host).to.have.attr("_use-host-aria-role");
+              expect($host).not.to.have.attr("aria-expanded");
+              if (UDExMode === UDExListMode.SingleContent) {
+                // Informational listitems (and grouped SingleContent treeitems) are not selectable.
+                expect($host).not.to.have.attr("aria-selected");
+                expect($host).not.to.have.attr("aria-checked");
+              } else {
+                expect($host).to.have.attr("aria-selected", "false");
+                expect($host).not.to.have.attr("aria-checked");
+              }
+            });
+            UDExAssertLeafName(cy.wrap($item), $item.attr("label")!);
+            UDExAssertPresentationItem(cy.wrap($item));
+          });
+          UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+          if (UDExMode === UDExListMode.MultiSelect) {
+            // Decorative controls keep their deliberate -1; only the row must omit tabindex.
+            UDExLeafHost("Alpha").shadow().find("[udex-checkbox]").should($checkbox => {
+              expect($checkbox).to.have.attr("tabindex", "-1");
+              expect($checkbox).to.have.attr("aria-hidden", "true");
+            });
+          }
+
+          if (UDExLayout.grouped) {
+            UDExHeaderHost().should($host => {
+              expect($host).to.have.attr("role", "treeitem");
+              expect($host).to.have.attr("aria-label", "Languages group");
+              if (UDExLayout.collapsible) {
+                expect($host).to.have.attr("aria-expanded", "true");
+              } else {
+                expect($host).not.to.have.attr("aria-expanded");
+              }
+              expect($host).not.to.have.attr("aria-description");
+              if (UDExMode !== UDExListMode.SingleContent) {
+                expect($host).to.have.attr("aria-selected", "false");
+                expect($host).not.to.have.attr("aria-checked");
+              } else {
+                expect($host).not.to.have.attr("aria-selected");
+                expect($host).not.to.have.attr("aria-checked");
+              }
+            });
+            UDExHeaderHost().shadow().find('[part="item"]').should($wrapper => {
+              expect($wrapper).to.have.attr("role", "presentation");
+              expect($wrapper).not.to.have.attr("aria-labelledby");
+            });
+            UDExHeaderHost().shadow().find('[role="tree"], [role="listbox"], [role="list"], [role="treeitem"]')
+              .should("not.exist");
+
+            if (UDExMode === UDExListMode.MultiSelect) {
+              UDExNestedHeader().should($host => {
+                expect($host).to.have.attr("role", "none");
+                expect($host).to.have.attr("_use-host-aria-role");
+                UDExInnerStateAttributes.forEach(UDExAttribute => {
+                  expect($host).not.to.have.attr(UDExAttribute);
+                });
+              });
+              UDExAssertPresentationItem(UDExNestedHeader());
+            } else if (UDExLayout.collapsible) {
+              UDExHeaderHost().shadow().find('[part="group-item"]').should($row => {
+                expect($row).to.have.attr("role", "presentation");
+                [...UDExInnerStateAttributes, "aria-controls", "aria-labelledby"].forEach(UDExAttribute => {
+                  expect($row).not.to.have.attr(UDExAttribute);
+                });
+              });
+            }
+          }
+        });
+
+        if (UDExMode !== UDExListMode.SingleContent) {
+          // Updated: pointer selection keeps Boolean native selection and complete-name live feedback.
+          it("selects a leaf with a native mouse click without blurring the combobox", () => {
+            UDExLeafHost("Beta").shadow().find('[part="item"]').should("be.visible").should($row => {
+              const UDExRow = $row[0];
+              const UDExRect = UDExRow.getBoundingClientRect();
+              const UDExRoot = UDExRow.getRootNode() as ShadowRoot;
+              const UDExHit = UDExRoot.elementFromPoint(
+                UDExRect.left + UDExRect.width / 2, UDExRect.top + UDExRect.height / 2
+              );
+              expect(UDExHit === UDExRow || UDExRow.contains(UDExHit), "native click reaches the leaf row").to.equal(true);
+            }).realClick({ scrollBehavior: false });
+
+            UDExSourceLeaf("Beta").should("have.attr", "selected");
+            UDExAssertHostSelection(UDExLeafHost("Beta"), true);
+            UDExAssertSelectionEvent("Beta", ["Beta"]);
+            UDExCombobox().should("be.focused");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+            UDExAssertPresentationItem(UDExLeafHost("Beta"));
+            UDExAssertSelectionStatus("Beta", "Selected");
+            if (UDExMode === UDExListMode.MultiSelect) {
+              UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+              UDExLeafHost("Beta").shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+              UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+              UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+              UDExAssertSelectionEvent("Beta", [], 2);
+              UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+              UDExAssertSelectionStatus("Beta", "Unselected");
+              cy.get("@comboboxBlur").should("not.have.been.called");
+            } else {
+              UDExPopover().should("not.have.attr", "open");
+              UDExCombobox().should("have.attr", "aria-expanded", "false");
+              UDExCombobox().should("not.have.attr", "aria-activedescendant");
+              UDExAssertSelectionStatus("Beta", "Selected");
+            }
+          });
+
+          (["Enter", "Space"] as const).forEach(UDExKey => {
+            // Updated: key activation uses native aria-selected and retains feedback after SingleSelect closes.
+            it(`selects a host-owned leaf with ${UDExKey} while DOM focus stays on the combobox`, () => {
+              // End reaches the last enabled leaf, not the disabled final item.
+              cy.realPress("End");
+              UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+              cy.realPress(UDExKey);
+
+              UDExSourceLeaf("Beta").should("have.attr", "selected");
+              UDExAssertHostSelection(UDExLeafHost("Beta"), true);
+              UDExAssertSelectionEvent("Beta", ["Beta"]);
+              UDExAssertSelectionStatus("Beta", "Selected");
+              if (UDExMode === UDExListMode.MultiSelect) {
+                UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+                cy.realPress(UDExKey);
+                UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+                UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+                UDExAssertSelectionEvent("Beta", [], 2);
+                UDExAssertSelectionStatus("Beta", "Unselected");
+              } else {
+                UDExPopover().should("not.have.attr", "open");
+                UDExCombobox().should("not.have.attr", "aria-activedescendant");
+                UDExAssertSelectionStatus("Beta", "Selected");
+              }
+              UDExCombobox().should("be.focused");
+              cy.get("@comboboxBlur").should("not.have.been.called");
+            });
+          });
+        }
+
+        if (UDExLayout.grouped && UDExMode === UDExListMode.MultiSelect) {
+          // Updated: partial group selection is false with Indeterminate description, removed on deselection.
+          it("selects and deselects enabled children by native clicks on the presentational group row", () => {
+            UDExNestedHeader().shadow().find('[part="item"]').realClick();
+
+            UDExSourceLeaf("Alpha").should("have.attr", "selected");
+            UDExSourceLeaf("Beta").should("have.attr", "selected");
+            UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+            // The disabled, unselected child keeps the group partially selected, not aria-selected=mixed.
+            UDExAssertHostSelection(UDExHeaderHost(), false, true);
+            UDExAssertSelectionEvent("Languages group", ["Alpha", "Beta"]);
+            UDExAssertActiveDescendant(UDExHeaderHost());
+            UDExAssertSelectionStatus("Languages group", "Indeterminate");
+            UDExAssertPresentationItem(UDExNestedHeader());
+
+            UDExNestedHeader().shadow().find('[part="item"]').realClick();
+
+            UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+            UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+            UDExAssertHostSelection(UDExHeaderHost(), false);
+            UDExAssertSelectionEvent("Languages group", [], 2);
+            UDExAssertActiveDescendant(UDExHeaderHost());
+            UDExAssertSelectionStatus("Languages group", "Unselected");
+            UDExCombobox().should("be.focused");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+          });
+
+          // Updated: keyboard partial selection describes Indeterminate and removes it when unselected.
+          it("toggles group selection exactly once per Enter or Space press from the combobox", () => {
+            UDExAssertActiveDescendant(UDExHeaderHost());
+            cy.realPress("Enter");
+            UDExAssertHostSelection(UDExHeaderHost(), false, true);
+            UDExAssertSelectionEvent("Languages group", ["Alpha", "Beta"]);
+            UDExAssertActiveDescendant(UDExHeaderHost());
+            UDExAssertSelectionStatus("Languages group", "Indeterminate");
+
+            cy.realPress("Space");
+            UDExAssertHostSelection(UDExHeaderHost(), false);
+            UDExAssertSelectionEvent("Languages group", [], 2);
+            UDExAssertActiveDescendant(UDExHeaderHost());
+            UDExAssertSelectionStatus("Languages group", "Unselected");
+            UDExAssertPresentationItem(UDExNestedHeader());
+            cy.get("@comboboxBlur").should("not.have.been.called");
+          });
+        }
+
+        if (UDExLayout.collapsible) {
+          // Updated: accordion state is native only; no hierarchy or expansion summary is repeated live.
+          it("toggles the chevron with a native click and still collapses and expands with arrow keys", () => {
+            const UDExHeader = () => UDExMode === UDExListMode.MultiSelect ? UDExNestedHeader() : UDExHeaderHost();
+            // Updated: expanded-header opening and subsequent accordion navigation both keep live status empty.
+            cy.realPress("Home");
+            UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+            UDExHeader().shadow().find("[udex-button].udex-list__group-heading__icon").realClick();
+
+            UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+            cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("have.attr", "collapsed");
+            UDExHeaderHost().find("[udex-list-item]").each($item => {
+              cy.wrap($item).should("have.attr", "collapsed");
+            });
+            UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+
+            cy.realPress("ArrowRight");
+            UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+            cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("not.have.attr", "collapsed");
+            UDExHeaderHost().find("[udex-list-item]").each($item => {
+              cy.wrap($item).should("not.have.attr", "collapsed");
+            });
+            UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+            cy.realPress("ArrowLeft");
+            UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+            cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("have.attr", "collapsed");
+            UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+            if (UDExMode !== UDExListMode.SingleContent) {
+              UDExAssertHostSelection(UDExHeaderHost(), false);
+            }
+            cy.get("@comboboxBlur").should("not.have.been.called");
+            cy.get("@selectionChange").should("not.have.been.called");
+          });
+        }
+      });
+    });
+  });
+});
+
+describe("SelectBox MultiSelect selected-tag IDREF regressions", () => {
+  const UDExTagGroup = () => cy.get("[udex-select-box]").shadow().find("[udex-tag-group]");
+  const UDExRenderedTags = () => UDExTagGroup().shadow().find("[udex-tag]");
+
+  function UDExAssertTags(UDExLabels: string[]) {
+    cy.get("[udex-select-box]").shadow().should($root => {
+      const UDExIds = Array.from($root[0].querySelectorAll("[id]"), UDExElement => UDExElement.id);
+      expect(new Set(UDExIds).size, "no duplicate IDs in the combobox shadow root").to.equal(UDExIds.length);
+      const UDExSourceTags = Array.from($root[0].querySelectorAll("[udex-tag-group] > [udex-tag]"));
+      expect(UDExSourceTags.map(UDExTag => UDExTag.getAttribute("text"))).to.deep.equal(UDExLabels);
+    });
+    if (!UDExLabels.length) {
+      UDExTagGroup().should("not.exist");
+      return;
+    }
+    UDExRenderedTags().should("have.length", UDExLabels.length).each(($tag, UDExIndex) => {
+      cy.wrap($tag).should("have.attr", "text", UDExLabels[UDExIndex]);
+      UDExSourceLeaf(UDExLabels[UDExIndex]).then($source => {
+        cy.wrap($tag).should("have.attr", "data-id", ($source[0] as UDExSelectBoxItemElement)._id);
+      });
+    });
+  }
+
+  UDExLayouts.forEach(UDExLayout => {
+    describe(UDExLayout.name, () => {
+      let UDExObserver: MutationObserver | undefined;
+
+      beforeEach(() => {
+        UDExMountSelectBox(UDExListMode.MultiSelect, UDExLayout);
+        UDExAssertTags([]);
+      });
+
+      afterEach(() => UDExObserver?.disconnect());
+
+      function UDExToggleLeaf(UDExLabel: string, UDExSelectedLabels: string[], UDExCallCount: number,
+        UDExActivation: "pointer" | "Enter" | "Space" = "pointer") {
+        UDExAssertActiveDescendant(UDExLeafHost(UDExLabel));
+        UDExLeafHost(UDExLabel).then($host => {
+          UDExCombobox().then($input => {
+            const UDExInput = $input[0];
+            const UDExRecords: MutationRecord[] = [];
+            UDExObserver = new MutationObserver(UDExChanges => UDExRecords.push(...UDExChanges));
+            UDExObserver.observe(UDExInput, {
+              attributes: true, attributeFilter: ["aria-activedescendant"], attributeOldValue: true,
+            });
+
+            if (UDExActivation === "pointer") {
+              UDExLeafHost(UDExLabel).shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+            } else {
+              cy.realPress(UDExActivation);
+            }
+            const UDExSelected = UDExSelectedLabels.includes(UDExLabel);
+            UDExSourceLeaf(UDExLabel).should(UDExSelected ? "have.attr" : "not.have.attr", "selected");
+            UDExAssertHostSelection(UDExLeafHost(UDExLabel), UDExSelected);
+            UDExAssertActiveDescendant(UDExLeafHost(UDExLabel));
+            UDExLeafHost(UDExLabel).should($current => expect($current[0], "same rendered leaf after toggling").to.equal($host[0]));
+            UDExCombobox().should($current => expect($current[0], "same input after toggling").to.equal(UDExInput));
+            UDExAssertSelectionStatus(UDExLabel, UDExSelected ? "Selected" : "Unselected");
+            UDExAssertSelectionEvent(UDExLabel, UDExSelectedLabels, UDExCallCount);
+            UDExAssertTags(UDExSelectedLabels);
+            UDExPopover().should("have.attr", "open");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+            cy.then(() => {
+              UDExRecords.push(...UDExObserver!.takeRecords());
+              UDExObserver!.disconnect();
+              // oldValue catches a temporary clear/rebind even if the final ID is unchanged.
+              UDExRecords.forEach(UDExRecord => expect(UDExRecord.oldValue, "active ID never cleared or redirected during selection")
+                .to.equal($host[0].id));
+              expect(UDExInput.getAttribute("aria-activedescendant")).to.equal($host[0].id);
+            });
+          });
+        });
+      }
+
+      // Updated: reopening expanded headers is silent; other hosts retain the fallback and tag semantics are unchanged.
+      it("keeps the active leaf's identity through first selection, additional selection, deselection and reopening with tags", () => {
+        if (UDExLayout.grouped) {
+          cy.realPress("ArrowDown");
+        }
+        UDExToggleLeaf("Alpha", ["Alpha"], 1);
+        cy.realPress("End");
+        UDExToggleLeaf("Beta", ["Alpha", "Beta"], 2, "Space");
+        cy.realPress("ArrowUp");
+        UDExToggleLeaf("Alpha", ["Beta"], 3);
+        UDExToggleLeaf("Alpha", ["Alpha", "Beta"], 4, "Enter");
+
+        cy.realPress("Escape");
+        UDExPopover().should("not.have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "false");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExAssertSupplementalStatus("");
+        UDExAssertTags(["Alpha", "Beta"]);
+        UDExCombobox().should("be.focused");
+        cy.realPress("ArrowDown");
+        UDExAssertOpenWithActiveDescendant(UDExLayout.grouped ? UDExHeaderHost() : UDExLeafHost("Alpha"),
+          UDExLayout.collapsible ? "" : "expanded");
+        if (UDExLayout.grouped) {
+          UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+          UDExAssertHostSelection(UDExHeaderHost(), false, true);
+        }
+        ["Alpha", "Beta"].forEach(UDExLabel => UDExAssertHostSelection(UDExLeafHost(UDExLabel), true));
+        cy.realPress("End");
+        UDExAssertNativeActiveDescendant(UDExLeafHost("Beta"), 2, 3, UDExLayout.grouped ? 2 : undefined);
+        UDExToggleLeaf("Beta", ["Alpha"], 5);
+        UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+      });
+
+      // Updated: tag removal changes aria-selected without changing source identity or remove payloads.
+      it("maps each rendered tag's delete icon to its original source item and bubbling remove payload", () => {
+        if (UDExLayout.grouped) {
+          cy.realPress("ArrowDown");
+        }
+        UDExToggleLeaf("Alpha", ["Alpha"], 1);
+        cy.realPress("End");
+        UDExToggleLeaf("Beta", ["Alpha", "Beta"], 2);
+        cy.get("#select-box-regression-fixture").then($fixture => {
+          $fixture[0].addEventListener("remove", cy.stub().as("tagRemoved"));
+        });
+
+        ["Alpha", "Beta"].forEach((UDExLabel, UDExIndex) => {
+          UDExSourceLeaf(UDExLabel).then($source => {
+            const UDExOriginal = $source[0] as UDExSelectBoxItemElement;
+            UDExRenderedTags().filter(`[text="${UDExLabel}"]`).should("have.attr", "data-id", UDExOriginal._id);
+            // Exercise UI5's icon event through Tag and TagGroup, not the removal callback directly.
+            UDExRenderedTags().filter(`[text="${UDExLabel}"]`).shadow().find('[ui5-icon][name="decline"]')
+              .click();
+            cy.get("@tagRemoved").should("have.callCount", UDExIndex + 1).its("lastCall.args.0")
+              .should((UDExEvent: CustomEvent<UDExSelectBoxRemoveEventDetail>) => {
+                expect(UDExEvent.type).to.equal("remove");
+                expect(UDExEvent.bubbles).to.equal(true);
+                expect(UDExEvent.detail.item).to.equal(UDExOriginal);
+                expect(UDExEvent.detail.item).to.have.property("selected", false);
+              });
+            UDExSourceLeaf(UDExLabel).should("not.have.attr", "selected");
+            UDExAssertHostSelection(UDExLeafHost(UDExLabel), false);
+            UDExAssertTags(UDExIndex === 0 ? ["Beta"] : []);
+            if (UDExIndex === 0) {
+              UDExSourceLeaf("Beta").should("have.attr", "selected");
+              UDExAssertHostSelection(UDExLeafHost("Beta"), true);
+            }
+            // Tag removal retains its existing callback-driven input focus restoration.
+            UDExCombobox().should("be.focused");
+          });
+        });
+        cy.get("@selectionChange").should("have.callCount", 2);
+        UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+      });
+    });
+  });
+});
+
+describe("SelectBox mixed collapsible and noncollapsible grouping", () => {
+  // Match the Grouping story's mixed layout, with no preselection to mask first-item activation.
+  const UDExMixedGroups = [
+    { label: "Backend Languages", collapsible: true, items: ["Python", "Java", "Ruby", "Node.js"] },
+    { label: "Frontend Languages", collapsible: false, items: ["JavaScript", "Swift", "React"] },
+  ];
+
+  [UDExListMode.SingleSelect, UDExListMode.MultiSelect].forEach(UDExMode => {
+    describe(UDExMode, () => {
+      function UDExAssertMixedTree(UDExGroups = UDExMixedGroups) {
+        UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+        UDExListHost().should("have.attr", "role", "tree");
+        UDExListHost().should("have.attr", "aria-label", "Languages");
+        UDExListHost().find('[role="option"], [role="listbox"]').should("not.exist");
+        UDExListHost().shadow().find('[role="tree"], [role="listbox"]').should("not.exist");
+        UDExHeaderHost().should("have.length", UDExGroups.length).each(($header, UDExIndex) => {
+          const UDExGroup = UDExGroups[UDExIndex];
+          UDExAssertHostPosition(cy.wrap($header), UDExIndex + 1, UDExGroups.length, 1);
+          cy.wrap($header).should($host => {
+            expect($host).to.have.attr("aria-label", UDExGroup.label);
+            expect($host[0]).to.have.property("mode", UDExMode);
+            expect($host[0]).to.have.property("_treeMode", true);
+            expect($host[0]).to.have.property("_groupAsListbox", false);
+            expect($host).not.to.have.attr("aria-checked");
+            expect($host.attr("aria-selected")).to.be.oneOf(["true", "false"]);
+            if (!UDExGroup.collapsible) {
+              expect($host).not.to.have.attr("aria-expanded");
+            }
+          });
+          cy.wrap($header).shadow().find('[part="item"]').should("have.attr", "role", "presentation");
+          cy.wrap($header).shadow().find('[role="listbox"], [role="treeitem"], [role="option"]').should("not.exist");
+          cy.wrap($header).shadow().find('[role="group"] > slot').should("have.length", 1).then($slot => {
+            // Verify composed ownership: the host treeitem owns a group containing its slotted leaves.
+            expect(($slot[0] as HTMLSlotElement).assignedElements()).to.deep.equal(Array.from($header[0].children));
+          });
+          if (UDExMode === UDExListMode.MultiSelect) {
+            const UDExRow = () => cy.wrap($header).shadow().find('[udex-list-item]#group-heading');
+            UDExRow().should("have.attr", "role", "none");
+            UDExRow().should($row => {
+              UDExInnerStateAttributes.forEach(UDExAttribute => expect($row).not.to.have.attr(UDExAttribute));
+            });
+            UDExAssertPresentationItem(UDExRow());
+            UDExRow().shadow().find('[role="listbox"]').should("not.exist");
+          }
+          cy.wrap($header).find("[udex-list-item]").should("have.length", UDExGroup.items.length).each(($leaf, UDExChildIndex) => {
+            UDExAssertHostPosition(cy.wrap($leaf), UDExChildIndex + 1, UDExGroup.items.length, 2);
+            UDExAssertLeafName(cy.wrap($leaf), UDExGroup.items[UDExChildIndex]);
+            cy.wrap($leaf).should("not.have.attr", "aria-expanded");
+            cy.wrap($leaf).should("not.have.attr", "aria-checked");
+            cy.wrap($leaf).should($host => expect($host.attr("aria-selected")).to.be.oneOf(["true", "false"]));
+            UDExAssertPresentationItem(cy.wrap($leaf));
+            cy.wrap($leaf).shadow().find('[role="listbox"]').should("not.exist");
+          });
+        });
+      }
+
+      beforeEach(() => {
+        cy.mount(
+          <div id="select-box-regression-fixture">
+            <UDExSelectBox label="Languages" mode={UDExMode}>
+              {UDExMixedGroups.map(UDExGroup => (
+                <UDExSelectBoxGroupHeader label={UDExGroup.label} collapsible={UDExGroup.collapsible}>
+                  {UDExGroup.items.map(UDExLabel => <UDExSelectBoxItem label={UDExLabel} disabled={UDExLabel === "Java"}></UDExSelectBoxItem>)}
+                </UDExSelectBoxGroupHeader>
+              ))}
+            </UDExSelectBox>
+          </div>
+        );
+        UDExCombobox().then($input => {
+          $input[0].addEventListener("blur", cy.stub().as("mixedOpeningBlur"));
+        });
+        UDExOpenSelectBox(UDExLayouts[2]);
+        // Updated: the expanded first header supplies native expansion without live duplication.
+        UDExAssertOpenWithActiveDescendant(UDExHeaderHost().first(), "");
+        UDExAssertHostPosition(UDExHeaderHost().first(), 1, 2, 1);
+        cy.get("@mixedOpeningBlur").should("not.have.been.called");
+      });
+
+      // Updated: both group types and their leaves expose Boolean aria-selected, never aria-checked.
+      it("owns both group types as treeitems with slotted groups, host selection states and no nested listboxes", () => {
+        UDExAssertMixedTree();
+        UDExHeaderHost().each($header => UDExAssertHostSelection(cy.wrap($header), false));
+        UDExListHost().find("[udex-list-item]").each($leaf => UDExAssertHostSelection(cy.wrap($leaf), false));
+        UDExLeafHost("Java").should("have.attr", "aria-disabled", "true");
+        UDExHeaderHost().first().should("have.attr", "aria-expanded", "true");
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+
+      it("keeps native levels, positions and host identity stable in both directions across collapsible and noncollapsible groups", () => {
+        UDExAssertMixedTree();
+        const UDExPath = [
+          { host: () => UDExHeaderHost().first(), position: 1, size: 2, level: 1 },
+          { host: () => UDExLeafHost("Python"), position: 1, size: 4, level: 2 },
+          // Disabled Java is skipped by navigation but remains the second sibling in the set.
+          { host: () => UDExLeafHost("Ruby"), position: 3, size: 4, level: 2 },
+          { host: () => UDExLeafHost("Node.js"), position: 4, size: 4, level: 2 },
+          ...(UDExMode === UDExListMode.MultiSelect
+            ? [{ host: () => UDExHeaderHost().last(), position: 2, size: 2, level: 1 }] : []),
+          { host: () => UDExLeafHost("JavaScript"), position: 1, size: 3, level: 2 },
+          { host: () => UDExLeafHost("Swift"), position: 2, size: 3, level: 2 },
+          { host: () => UDExLeafHost("React"), position: 3, size: 3, level: 2 },
+        ];
+        UDExCombobox().then($input => {
+          const UDExOriginalInput = $input[0];
+          UDExListHost().find("[udex-list-group-header], [udex-list-item]").then($hosts => {
+            const UDExOriginalHosts = Array.from($hosts);
+            const UDExAssertStep = (UDExStep: typeof UDExPath[number]) => {
+              UDExAssertNativeActiveDescendant(UDExStep.host(), UDExStep.position, UDExStep.size, UDExStep.level);
+              UDExAssertHostSelection(UDExStep.host(), false);
+              UDExListHost().find("[udex-list-group-header], [udex-list-item]").should($current => {
+                expect(Array.from($current), "navigation preserves each rendered host and its ID owner").to.deep.equal(UDExOriginalHosts);
+              });
+              UDExCombobox().should($current => expect($current[0]).to.equal(UDExOriginalInput));
+              UDExHeaderHost().first().should("have.attr", "aria-expanded", "true");
+              UDExHeaderHost().last().should("not.have.attr", "aria-expanded");
+              UDExAssertNativeHostStates();
+              cy.get("@selectionChange").should("not.have.been.called");
+              cy.get("@comboboxBlur").should("not.have.been.called");
+              cy.get("@mixedOpeningBlur").should("not.have.been.called");
+            };
+
+            UDExPath.slice(1).forEach(UDExStep => {
+              cy.realPress("ArrowDown");
+              UDExAssertStep(UDExStep);
+            });
+            UDExAssertMixedTree();
+            UDExPath.slice(0, -1).reverse().forEach(UDExStep => {
+              cy.realPress("ArrowUp");
+              UDExAssertStep(UDExStep);
+            });
+            // Wrapping must not change the hierarchy or silently select the active leaf.
+            cy.realPress("ArrowUp");
+            UDExAssertStep(UDExPath[UDExPath.length - 1]);
+            cy.realPress("ArrowDown");
+            UDExAssertStep(UDExPath[0]);
+            UDExAssertMixedTree();
+            cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+          });
+        });
+      });
+
+      it("toggles only the collapsible group by pointer and arrows without changing tree ownership or input focus", () => {
+        const UDExChevronHost = UDExMode === UDExListMode.MultiSelect
+          ? UDExHeaderHost().first().shadow().find('[udex-list-item]#group-heading') : UDExHeaderHost().first();
+        UDExChevronHost.shadow().find("[udex-button].udex-list__group-heading__icon").realClick();
+        UDExHeaderHost().first().should("have.attr", "aria-expanded", "false");
+        cy.get("[udex-select-box]").find('[udex-select-box-group-header][label="Backend Languages"]').should("have.attr", "collapsed");
+        UDExHeaderHost().first().find("[udex-list-item]").each($leaf => cy.wrap($leaf).should("have.attr", "collapsed"));
+        UDExAssertActiveDescendant(UDExHeaderHost().first());
+        cy.realPress("ArrowRight");
+        UDExHeaderHost().first().should("have.attr", "aria-expanded", "true");
+        UDExHeaderHost().first().find("[udex-list-item]").each($leaf => cy.wrap($leaf).should("not.have.attr", "collapsed"));
+        cy.realPress("ArrowLeft");
+        UDExHeaderHost().first().should("have.attr", "aria-expanded", "false");
+        cy.realPress("ArrowDown");
+        UDExAssertActiveDescendant(UDExMode === UDExListMode.MultiSelect ? UDExHeaderHost().last() : UDExLeafHost("JavaScript"));
+        cy.realPress("ArrowLeft");
+        UDExHeaderHost().last().should("not.have.attr", "aria-expanded");
+        UDExHeaderHost().last().should("not.have.attr", "collapsed");
+        cy.realPress("Home");
+        cy.realPress("ArrowRight");
+        UDExHeaderHost().first().should("have.attr", "aria-expanded", "true");
+        cy.get("[udex-select-box]").find('[udex-select-box-group-header][label="Backend Languages"]').should("not.have.attr", "collapsed");
+        UDExAssertMixedTree();
+        UDExAssertActiveDescendant(UDExHeaderHost().first());
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@mixedOpeningBlur").should("not.have.been.called");
+      });
+
+      // Updated: partial MultiSelect groups are false with an Indeterminate description, not mixed selection.
+      it("updates the leaf's host selection state without duplicating inner selection semantics", () => {
+        cy.realPress("ArrowDown");
+        UDExAssertActiveDescendant(UDExLeafHost("Python"));
+        cy.realPress("Enter");
+        UDExSourceLeaf("Python").should("have.attr", "selected");
+        UDExAssertHostSelection(UDExLeafHost("Python"), true);
+        UDExAssertHostSelection(UDExHeaderHost().first(), false, UDExMode === UDExListMode.MultiSelect);
+        UDExAssertHostSelection(UDExHeaderHost().last(), false);
+        UDExAssertSelectionEvent("Python", ["Python"]);
+        UDExAssertSelectionStatus("Python", "Selected");
+        UDExAssertMixedTree();
+        UDExSourceLeaf("Java").should("not.have.attr", "selected");
+        UDExPopover().should(UDExMode === UDExListMode.MultiSelect ? "have.attr" : "not.have.attr", "open");
+        UDExCombobox().should("be.focused");
+        cy.get("@mixedOpeningBlur").should("not.have.been.called");
+      });
+
+      // Updated: navigation clears filtered result counts; native positions retain the filtered hierarchy.
+      it("keeps explicit group roles and recalculates positions when filtering retains both groups, then only the noncollapsible group", () => {
+        cy.realType("Java");
+        UDExStatus().should("have.text", "3 results returned.");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExListHost().find("[_active-descendant]").should("not.exist");
+        UDExAssertMixedTree([
+          { ...UDExMixedGroups[0], items: ["Java"] },
+          { ...UDExMixedGroups[1], items: ["JavaScript"] },
+        ]);
+        UDExCombobox().clear();
+        cy.realType("Swift");
+        UDExStatus().should("have.text", "2 results returned.");
+        UDExAssertMixedTree([{ ...UDExMixedGroups[1], items: ["Swift"] }]);
+        UDExListHost().find("[_active-descendant]").should("not.exist");
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExMode === UDExListMode.MultiSelect ? UDExHeaderHost() : UDExHeaderHost().find("[udex-list-item]"),
+          1, 1, UDExMode === UDExListMode.MultiSelect ? 1 : 2);
+        UDExAssertHostSelection(UDExMode === UDExListMode.MultiSelect ? UDExHeaderHost() : UDExHeaderHost().find("[udex-list-item]"), false);
+        UDExCombobox().clear();
+        UDExAssertMixedTree();
+        cy.realPress("ArrowDown");
+        UDExAssertActiveDescendant(UDExHeaderHost().first());
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@mixedOpeningBlur").should("not.have.been.called");
+      });
+    });
+  });
+});
+
+describe("SelectBox Grouping with all selected tags overflowing", () => {
+  it("omits the empty tokenizer listbox while preserving More and input-focused tree highlighting", () => {
+    const UDExFrontendLabels = [
+      "JavaScript is a lightweight interpreted programming language", "Swift",
+      "HyperText Markup", "Cascading Style Sheets", "React", "Angular", "Django",
+    ];
+    const UDExTagGroup = () => cy.get("[udex-select-box]").shadow().find("[udex-tag-group]");
+    const UDExTokenizer = () => UDExTagGroup().shadow().find(".udex-tag-group__tokenizer");
+    const UDExMoreButton = () => UDExTokenizer().shadow().find(".ui5-tokenizer-more-text");
+
+    function UDExAssertTokenizerList(UDExVisibleCount: number) {
+      UDExTokenizer().find("[udex-tag]").should("have.length", 5);
+      UDExTokenizer().shadow().find(".ui5-tokenizer--list").should($list => {
+        const UDExTags = Array.from($list[0].querySelectorAll("slot"))
+          .flatMap(UDExSlot => UDExSlot.assignedElements());
+        const UDExVisibleTags = UDExTags.filter(UDExTokenElement => !UDExTokenElement.hasAttribute("overflows"));
+        expect(UDExTags).to.have.length(5);
+        expect(UDExVisibleTags).to.have.length(UDExVisibleCount);
+        expect($list).to.have.attr("role", UDExVisibleCount ? "listbox" : "presentation");
+        if (UDExVisibleCount) {
+          const UDExTokenizerHost = ($list[0].getRootNode() as ShadowRoot).host as Tokenizer;
+          expect($list).to.have.attr("aria-label", UDExTokenizerHost.tokenizerLabel);
+          UDExVisibleTags.forEach(UDExTokenElement => {
+            expect(UDExTokenElement.shadowRoot?.querySelector('[role="option"]'), "restored listbox owns an option").to.exist;
+          });
+        } else {
+          ["aria-label", "aria-description", "aria-disabled", "aria-readonly"].forEach(UDExAttribute => {
+            expect($list).not.to.have.attr(UDExAttribute);
+          });
+          expect($list.parent().find('[role="listbox"]')).to.have.length(0);
+        }
+      });
+    }
+
+    // Match the Grouping story's 320px width, mixed groups and five selected frontend leaves.
+    cy.mount(
+      <div id="select-box-regression-fixture" style="width: 320px;">
+        <UDExSelectBox label="Programming languages" mode={UDExListMode.MultiSelect} height="400px">
+          <UDExSelectBoxGroupHeader label="Backend Languages" collapsible>
+            {["Python", "Java", "Ruby", "Node.js"].map(UDExLabel => (
+              <UDExSelectBoxItem label={UDExLabel} disabled={UDExLabel === "Java"}></UDExSelectBoxItem>
+            ))}
+          </UDExSelectBoxGroupHeader>
+          <UDExSelectBoxGroupHeader label="Frontend Languages" indeterminate selected>
+            {UDExFrontendLabels.map((UDExLabel, UDExIndex) => (
+              <UDExSelectBoxItem label={UDExLabel} selected={UDExIndex >= 2}></UDExSelectBoxItem>
+            ))}
+          </UDExSelectBoxGroupHeader>
+        </UDExSelectBox>
+      </div>
+    );
+    UDExSourceLeaf("HyperText Markup").should("have.attr", "selected");
+    UDExTokenizer().find("[udex-tag][overflows]").should("have.length", 5);
+    UDExAssertTokenizerList(0);
+    UDExMoreButton().should("be.visible").and("have.attr", "role", "button");
+    UDExMoreButton().should($more => {
+      expect($more.text()).to.contain("5");
+      // SelectBox deliberately skips More in Tab order, but it must remain exposed and clickable.
+      expect($more).to.have.attr("tabindex", "-1");
+      let UDExNode: HTMLElement | null = $more[0];
+      while (UDExNode) {
+        expect(UDExNode.getAttribute("aria-hidden")).not.to.equal("true");
+        expect(UDExNode.hasAttribute("hidden") || UDExNode.hasAttribute("inert")).to.equal(false);
+        UDExNode = UDExNode.assignedSlot || UDExNode.parentElement
+          || ((UDExNode.getRootNode() as ShadowRoot).host as HTMLElement | undefined) || null;
+      }
+    });
+    cy.get("[udex-select-box]").then($selectBox => {
+      $selectBox[0].addEventListener("show-more", cy.stub().as("overflowShowMore"));
+    });
+    cy.get("#select-box-regression-fixture").then($fixture => {
+      $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+    });
+    UDExPopover().then($popover => {
+      $popover[0].addEventListener("ui5-open", cy.stub().as("groupingPopoverOpened"), { once: true });
+    });
+    UDExCombobox().then($input => {
+      $input[0].addEventListener("blur", cy.stub().as("groupingOpeningBlur"));
+    });
+
+    // More opens SelectBox's popup, not TagGroup's tooltip, and focus expands the tokenizer.
+    UDExMoreButton().click();
+    cy.get("@overflowShowMore").should("have.been.calledOnce");
+    cy.get("@groupingPopoverOpened").should("have.been.calledOnce");
+    UDExPopover().should("have.attr", "open");
+    UDExCombobox().should("have.attr", "aria-expanded", "true");
+    UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+    UDExListHost().should("have.attr", "role", "tree");
+    UDExListHost().should("have.attr", "aria-label", "Programming languages");
+    UDExListHost().then($list => {
+      UDExCombobox().should("have.attr", "aria-controls", $list[0].id);
+    });
+    UDExAssertActiveDescendant(UDExHeaderHost().first());
+    UDExAssertTokenizerList(5);
+    cy.realPress("ArrowDown");
+    UDExAssertActiveDescendant(UDExLeafHost("Python"));
+    cy.get("@groupingOpeningBlur").should("not.have.been.called");
+    UDExAssertTokenizerList(5);
+    UDExTagGroup().shadow().find("[udex-tooltip][open]").should("not.exist");
+    cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("have.length", 5);
+    cy.get("@selectionChange").should("not.have.been.called");
+  });
+});
+
+describe("SelectBox actionable flat popup accessibility", () => {
+  const UDExActionLayouts = [
+    { name: "first icon only", slots: ["firstIcon"] },
+    { name: "second icon only", slots: ["secondIcon"] },
+    { name: "both icons", slots: ["firstIcon", "secondIcon"] },
+  ];
+
+  UDExModes.forEach(UDExMode => {
+    UDExActionLayouts.forEach(UDExLayout => {
+      describe(`${UDExMode} / ${UDExLayout.name}`, () => {
+        const UDExAction = (UDExSlot: string) => UDExLeafHost("Alpha").find(`[udex-button][slot="${UDExSlot}"]`);
+        const UDExActionName = (UDExSlot: string) => UDExSlot === "firstIcon" ? "First action" : "Second action";
+        const UDExEventName = (UDExSlot: string) => UDExSlot === "firstIcon" ? "first-icon-click" : "second-icon-click";
+
+        function UDExAssertActionEvent(UDExSlot: string, UDExCount: number) {
+          UDExSourceLeaf("Alpha").then($source => {
+            UDExAction(UDExSlot).then($button => {
+              cy.get(`@${UDExSlot}`).should("have.callCount", UDExCount).its("lastCall.args.0")
+                .should((UDExEvent: CustomEvent<UDExSelectBoxIconClickEventDetail>) => {
+                  expect(UDExEvent.type).to.equal(UDExEventName(UDExSlot));
+                  expect(UDExEvent.bubbles).to.equal(true);
+                  expect(UDExEvent.detail.item).to.equal($source[0]);
+                  expect(UDExEvent.detail.item?.label).to.equal("Alpha");
+                  expect(UDExEvent.detail.item?.supportingText).to.equal("First choice");
+                  expect(UDExEvent.detail.item?.getAttribute("additional-text")).to.equal("Code A");
+                  expect(UDExEvent.detail.originalEvent.type).to.equal("click");
+                }).then((UDExEvent: CustomEvent<UDExSelectBoxIconClickEventDetail>) => {
+                  // A shadow-crossing native event can clear its target after dispatch.
+                  cy.get(`@${UDExSlot}ClickSnapshot`).should("have.callCount", UDExCount)
+                    .its("lastCall.args.0").should(UDExSnapshot => {
+                      expect(UDExSnapshot.event).to.equal(UDExEvent.detail.originalEvent);
+                      expect(UDExSnapshot.target).to.equal($button[0]);
+                    });
+                });
+            });
+          });
+        }
+
+        beforeEach(() => {
+          cy.mount(
+            <div id="select-box-regression-fixture">
+              <UDExSelectBox label="Languages" mode={UDExMode}>
+                <UDExSelectBoxItem label="Alpha" supportingText="First choice" additionalText="Code A">
+                  {UDExLayout.slots.map(UDExSlot => (
+                    <UDExButton slot={UDExSlot} accessibleName={UDExActionName(UDExSlot)} design="Tertiary"
+                      icon={UDExSlot === "firstIcon" ? "action" : "email"} size="Small"></UDExButton>
+                  ))}
+                </UDExSelectBoxItem>
+                <UDExSelectBoxItem label="Beta"></UDExSelectBoxItem>
+                <UDExSelectBoxItem label="Unavailable" disabled></UDExSelectBoxItem>
+              </UDExSelectBox>
+            </div>
+          );
+          cy.get("#select-box-regression-fixture").then($fixture => {
+            UDExLayout.slots.forEach(UDExSlot => {
+              const UDExClickSnapshot = cy.stub().as(`${UDExSlot}ClickSnapshot`);
+              // Preserve the existing consumer contract: actions stop their original click, not row handlers.
+              const UDExHandler = cy.stub().callsFake((UDExEvent: CustomEvent<UDExSelectBoxIconClickEventDetail>) => {
+                UDExClickSnapshot({
+                  event: UDExEvent.detail.originalEvent,
+                  target: UDExEvent.detail.originalEvent.target,
+                });
+                UDExEvent.detail.originalEvent.stopPropagation();
+              }).as(UDExSlot);
+              $fixture[0].addEventListener(UDExEventName(UDExSlot), UDExHandler);
+            });
+          });
+          UDExCombobox().then($input => {
+            $input[0].addEventListener("blur", cy.stub().as("actionOpeningBlur"));
+          });
+          UDExOpenSelectBox(UDExLayouts[0]);
+          UDExAssertOpenWithActiveDescendant(UDExLeafHost("Alpha"));
+          UDExAssertHostPosition(UDExLeafHost("Alpha"), 1, 3, 1);
+          cy.get("@actionOpeningBlur").should("not.have.been.called");
+        });
+
+        // Updated: actionable native treeitems use Boolean selection without a parallel checked state.
+        it("exposes every leaf as a named level-1 treeitem and keeps focusable actions outside option semantics", () => {
+          UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+          UDExListHost().should($host => {
+            expect($host).to.have.attr("role", "tree");
+            expect($host).to.have.attr("aria-label", "Languages");
+            if (UDExMode === UDExListMode.MultiSelect) {
+              expect($host).to.have.attr("aria-multiselectable", "true");
+            } else {
+              expect($host).not.to.have.attr("aria-multiselectable");
+            }
+          });
+          UDExListHost().shadow().find('[role="tree"], [role="listbox"]').should("not.exist");
+          UDExListHost().find('[role="option"], [udex-list-group-header]').should("not.exist");
+          UDExListHost().find("[udex-list-item]").should("have.length", 3).each(($leaf, UDExIndex) => {
+            UDExAssertHostPosition(cy.wrap($leaf), UDExIndex + 1, 3, 1);
+            cy.wrap($leaf).should("not.have.attr", "aria-expanded");
+            cy.wrap($leaf).should($host => {
+              if (UDExMode === UDExListMode.SingleContent) {
+                expect($host).not.to.have.attr("aria-selected");
+                expect($host).not.to.have.attr("aria-checked");
+              } else {
+                expect($host).to.have.attr("aria-selected", "false");
+                expect($host).not.to.have.attr("aria-checked");
+              }
+            });
+            UDExAssertPresentationItem(cy.wrap($leaf));
+          });
+          UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha", "First choice", "Code A");
+          UDExAssertLeafName(UDExLeafHost("Beta"), "Beta");
+          UDExAssertLeafName(UDExLeafHost("Unavailable"), "Unavailable");
+          UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+          UDExLayout.slots.forEach(UDExSlot => {
+            UDExAction(UDExSlot).should($button => {
+              expect($button).to.have.length(1);
+              expect($button).not.to.have.attr("disabled");
+              // Walk slots and shadow boundaries too: closest() alone misses presentational option children.
+              let UDExNode: HTMLElement | null = $button[0];
+              while (UDExNode) {
+                expect(UDExNode.getAttribute("role"), "no composed option ancestor").not.to.equal("option");
+                expect(UDExNode.getAttribute("aria-hidden"), "action is not hidden").not.to.equal("true");
+                expect(UDExNode.hasAttribute("inert"), "action is not inert").to.equal(false);
+                UDExNode = UDExNode.assignedSlot || UDExNode.parentElement
+                  || ((UDExNode.getRootNode() as ShadowRoot).host as HTMLElement | undefined) || null;
+              }
+            });
+            UDExAction(UDExSlot).shadow().find("button").should("not.be.disabled").should($button => {
+              expect($button).to.have.attr("aria-label", UDExActionName(UDExSlot));
+              expect($button).not.to.have.attr("aria-hidden", "true");
+              expect($button).not.to.have.attr("aria-disabled", "true");
+              expect(($button[0] as HTMLButtonElement).tabIndex).to.be.at.least(0);
+            });
+          });
+          UDExAssertActiveDescendant(UDExLeafHost("Alpha"));
+          cy.get("@actionOpeningBlur").should("not.have.been.called");
+        });
+
+        it("preserves pointer action events with the original source item and click payload", () => {
+          UDExLayout.slots.forEach(UDExSlot => {
+            UDExAction(UDExSlot).realClick({ scrollBehavior: false });
+            UDExAssertActionEvent(UDExSlot, 1);
+          });
+          UDExLayout.slots.forEach(UDExSlot => cy.get(`@${UDExSlot}`).should("have.been.calledOnce"));
+          UDExPopover().should("have.attr", "open");
+          cy.get("@selectionChange").should("not.have.been.called");
+          UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+          UDExAssertPresentationItem(UDExLeafHost("Alpha"));
+        });
+
+        // Updated: returning from an action restores native positions with an empty live status.
+        it("preserves Enter and Space action activation and the existing real-icon focus path", () => {
+          if (UDExLayout.slots[0] === "firstIcon") {
+            cy.realPress("ArrowRight");
+          } else {
+            // Second-only ArrowRight entry is unchanged and reviewed separately; test the focusable action itself.
+            UDExAction("secondIcon").then($button => $button[0].focus());
+          }
+          UDExLayout.slots.forEach((UDExSlot, UDExIndex) => {
+            if (UDExIndex > 0) {
+              cy.realPress("ArrowRight");
+            }
+            UDExAction(UDExSlot).should("be.focused");
+            UDExCombobox().should("not.be.focused");
+            if (UDExLayout.slots[0] === "firstIcon") {
+              UDExCombobox().should("not.have.attr", "aria-activedescendant");
+              UDExListHost().find("[_active-descendant], ._udex-active-descendant").should("not.exist");
+            }
+            (["Enter", "Space"] as const).forEach((UDExKey, UDExKeyIndex) => {
+              cy.realPress(UDExKey);
+              UDExAssertActionEvent(UDExSlot, UDExKeyIndex + 1);
+              UDExAction(UDExSlot).should("be.focused");
+              UDExPopover().should("have.attr", "open");
+              cy.get("@selectionChange").should("not.have.been.called");
+            });
+          });
+          UDExLayout.slots.forEach(UDExSlot => cy.get(`@${UDExSlot}`).should("have.callCount", 2));
+          if (UDExLayout.slots[0] === "firstIcon") {
+            if (UDExLayout.slots.length === 2) {
+              cy.realPress("ArrowLeft");
+              UDExAction("firstIcon").should("be.focused");
+            }
+            cy.realPress("ArrowLeft");
+            UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 3, 1);
+            if (UDExMode === UDExListMode.SingleContent) {
+              UDExLeafHost("Alpha").should("not.have.attr", "aria-selected");
+            } else {
+              UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+            }
+          }
+          cy.realPress("Escape");
+          UDExPopover().should("not.have.attr", "open");
+          UDExCombobox().should("be.focused");
+          UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+        });
+      });
+    });
+  });
+});
+
+describe("SelectBox first keyboard opening and outside-background dismissal", () => {
+  UDExLayouts.forEach(UDExLayout => {
+    // Updated: expanded headers open silently; other hosts retain the fallback on first opening and native-Tab reopening.
+    it(`activates the first navigable ${UDExLayout.name} item on keyboard opening, including after an outside click and native Tab return`, () => {
+      const UDExItems = [
+        <UDExSelectBoxItem label="Alpha"></UDExSelectBoxItem>,
+        <UDExSelectBoxItem label="Beta"></UDExSelectBoxItem>,
+        <UDExSelectBoxItem label="Unavailable" disabled></UDExSelectBoxItem>,
+      ];
+      cy.mount(
+        <div id="select-box-regression-fixture">
+          <button id="before-select-box">Previous</button>
+          <div id="select-box-outside-background">Outside dropdown</div>
+          <UDExSelectBox label="Languages" mode={UDExListMode.SingleSelect}>
+            {UDExLayout.grouped ? (
+              <UDExSelectBoxGroupHeader label="Languages group" collapsible={UDExLayout.collapsible}>
+                {UDExItems}
+              </UDExSelectBoxGroupHeader>
+            ) : UDExItems}
+          </UDExSelectBox>
+        </div>
+      );
+      cy.get("#select-box-regression-fixture").then($fixture => {
+        $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+      });
+      cy.get("[udex-select-box]").then($host => {
+        $host[0].addEventListener("close", cy.stub().as("outsideDropdownClosed"));
+      });
+      UDExPopover().then($popover => {
+        $popover[0].addEventListener("ui5-open", cy.stub().as("firstKeyboardPopoverOpened"));
+      });
+      UDExCombobox().then($input => {
+        $input[0].addEventListener("blur", cy.stub().as("comboboxBlur"));
+      });
+      const UDExAssertNativeInputFocus = () => UDExCombobox().should("be.focused").should($input => {
+        const UDExRoot = $input[0].getRootNode() as ShadowRoot;
+        expect($input[0].ownerDocument.activeElement).to.equal(UDExRoot.host);
+        expect(UDExRoot.activeElement).to.equal($input[0]);
+      });
+      cy.get("#before-select-box").realClick();
+      cy.realPress("Tab");
+
+      [1, 2].forEach(UDExCycle => {
+        UDExAssertNativeInputFocus();
+        UDExPopover().should("not.have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "false");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExListHost().find("[_active-descendant]").should("not.exist");
+        UDExAssertSupplementalStatus("");
+
+        cy.realPress("ArrowDown");
+        cy.get("@firstKeyboardPopoverOpened").should("have.callCount", UDExCycle);
+        UDExAssertOpenWithActiveDescendant(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"),
+          UDExLayout.collapsible ? "" : "expanded");
+        UDExAssertHostPosition(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"), 1,
+          UDExLayout.collapsible ? 1 : 3, UDExLayout.grouped ? UDExLayout.collapsible ? 1 : 2 : undefined);
+        UDExAssertNativeInputFocus();
+        cy.get("@comboboxBlur").should("have.callCount", UDExCycle - 1);
+        cy.get("@selectionChange").should("not.have.been.called");
+
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExLeafHost(UDExLayout.collapsible ? "Alpha" : "Beta"),
+          UDExLayout.collapsible ? 1 : 2, 3, UDExLayout.grouped ? 2 : undefined);
+        UDExAssertHostSelection(UDExLeafHost(UDExLayout.collapsible ? "Alpha" : "Beta"), false);
+        UDExListHost().find("[_active-descendant]").should("have.length", 1);
+        UDExAssertNativeInputFocus();
+        cy.realPress("End");
+        UDExAssertNativeActiveDescendant(UDExLeafHost("Beta"), 2, 3, UDExLayout.grouped ? 2 : undefined);
+        UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+        UDExAssertNativeInputFocus();
+        cy.get("@comboboxBlur").should("have.callCount", UDExCycle - 1);
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+
+        if (UDExCycle === 1) {
+          // This nonfocusable background sits before the input in sequential focus order.
+          cy.get("#select-box-outside-background").realClick();
+          cy.get("@outsideDropdownClosed").should("have.been.calledOnce");
+          UDExPopover().should("not.have.attr", "open");
+          UDExCombobox().should("have.attr", "aria-expanded", "false");
+          UDExCombobox().should("not.have.attr", "aria-activedescendant");
+          UDExListHost().find("[_active-descendant]").should("not.exist");
+          UDExAssertSupplementalStatus("");
+          UDExCombobox().should("not.be.focused").should($input => {
+            expect($input[0].ownerDocument.activeElement).to.equal($input[0].ownerDocument.body);
+            expect(($input[0].getRootNode() as ShadowRoot).activeElement).to.equal(null);
+          });
+          cy.get("@comboboxBlur").should("have.been.calledOnce");
+          // Do not synthesize focus or click the combobox: Tab must restore native keyboard entry.
+          cy.realPress("Tab");
+        }
+      });
+    });
+  });
+});
+
+describe("SelectBox native navigation without redundant live metadata", () => {
+  UDExLayouts.forEach(UDExLayout => {
+    // Updated: a selected child keeps the expanded popup fallback even when its parent is auto-expanded.
+    it(`restores the selected SingleSelect ${UDExLayout.name} child immediately on each keyboard opening${UDExLayout.collapsible ? " after expanding its collapsed group" : ""}`, () => {
+      const UDExItems = [
+        <UDExSelectBoxItem label="Alpha" supportingText="First choice"></UDExSelectBoxItem>,
+        <UDExSelectBoxItem label="Beta" supportingText="Second choice" selected></UDExSelectBoxItem>,
+        <UDExSelectBoxItem label="Unavailable" disabled></UDExSelectBoxItem>,
+      ];
+      cy.mount(
+        <div id="select-box-regression-fixture">
+          <button id="before-select-box">Previous</button>
+          <UDExSelectBox label="Languages" mode={UDExListMode.SingleSelect}>
+            {UDExLayout.grouped ? (
+              <UDExSelectBoxGroupHeader label="Languages group" supportingText="Choose a language"
+                collapsible={UDExLayout.collapsible} collapsed={UDExLayout.collapsible}>
+                {UDExItems}
+              </UDExSelectBoxGroupHeader>
+            ) : UDExItems}
+          </UDExSelectBox>
+        </div>
+      );
+      cy.get("#select-box-regression-fixture").then($fixture => {
+        $fixture[0].addEventListener("selection-change", cy.stub().as("selectionChange"));
+      });
+      UDExPopover().then($popover => {
+        $popover[0].addEventListener("ui5-open", cy.stub().as("selectedPopoverOpened"));
+      });
+      cy.get("[udex-select-box]").then($selectBox => {
+        $selectBox[0].addEventListener("close", cy.stub().as("selectedDropdownClosed"));
+      });
+      UDExCombobox().then($input => {
+        $input[0].addEventListener("blur", cy.stub().as("comboboxBlur"));
+      });
+      cy.get("#before-select-box").realClick();
+      cy.realPress("Tab");
+      UDExCombobox().should("be.focused");
+
+      [1, 2].forEach(UDExCycle => {
+        UDExPopover().should("not.have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "false");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExAssertSupplementalStatus("");
+        if (UDExLayout.collapsible) {
+          cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("have.attr", "collapsed");
+          UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+        }
+
+        cy.realPress("ArrowDown");
+        cy.get("@selectedPopoverOpened").should("have.callCount", UDExCycle);
+        UDExAssertOpenWithActiveDescendant(UDExLeafHost("Beta"), "expanded");
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+        if (UDExLayout.collapsible) {
+          UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+          cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("not.have.attr", "collapsed");
+        }
+
+        UDExAssertHostPosition(UDExLeafHost("Beta"), 2, 3, UDExLayout.grouped ? 2 : undefined);
+        UDExListHost().find("[_active-descendant]").should("have.length", 1);
+        UDExLeafHost("Alpha").should("not.have.attr", "_active-descendant");
+        UDExLeafHost("Beta").should("have.attr", "aria-selected", "true");
+        UDExSourceLeaf("Beta").should("have.attr", "selected");
+        UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+        UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+        UDExAssertLeafName(UDExLeafHost("Beta"), "Beta", "Second choice");
+        UDExAssertPresentationItem(UDExLeafHost("Beta"));
+
+        // Skip the disabled final leaf and wrap to the next navigable host, not Beta again.
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"), 1,
+          UDExLayout.collapsible ? 1 : 3, UDExLayout.grouped ? UDExLayout.collapsible ? 1 : 2 : undefined);
+        UDExAssertHostSelection(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"), false);
+
+        if (UDExLayout.collapsible) {
+          // Initial activation must wait until the selected child's group has rendered expanded.
+          UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+          cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("not.have.attr", "collapsed");
+          UDExHeaderHost().find("[udex-list-item]").each($item => {
+            cy.wrap($item).should("not.have.attr", "collapsed");
+          });
+          cy.realPress("Home");
+          UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+          cy.realPress("ArrowLeft");
+          UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+          UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+          cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("have.attr", "collapsed");
+        }
+
+        cy.realPress("Escape");
+        cy.get("@selectedDropdownClosed").should("have.callCount", UDExCycle);
+        UDExPopover().should("not.have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "false");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExListHost().find("[_active-descendant]").should("not.exist");
+        UDExAssertSupplementalStatus("");
+        UDExCombobox().should("be.focused");
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+    });
+  });
+
+  // Updated: native hosts alone expose per-level positions and states; live navigation is empty.
+  it("navigates two country groups with native names and exact per-level positions without live metadata", () => {
+    UDExMountCountrySelectBox();
+    UDExCombobox().should("have.attr", "aria-label", "Country");
+    UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+    UDExListHost().should("have.attr", "role", "tree");
+    UDExListHost().then($list => {
+      UDExCombobox().should("have.attr", "aria-controls", $list[0].id);
+    });
+    UDExHeaderHost().should("have.length", 2);
+    UDExListHost().find("[udex-list-item]").should("have.length", 6);
+
+    UDExCountryGroups.forEach((UDExGroup, UDExGroupIndex) => {
+      if (UDExGroupIndex > 0) {
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExHeaderHost().eq(UDExGroupIndex), UDExGroupIndex + 1, 2, 1);
+      } else {
+        // Updated: the expanded first header is active from opening with no live expansion duplicate.
+        UDExAssertOpenWithActiveDescendant(UDExHeaderHost().eq(UDExGroupIndex), "");
+      }
+      UDExAssertHostPosition(UDExHeaderHost().eq(UDExGroupIndex), UDExGroupIndex + 1, 2, 1);
+      UDExHeaderHost().eq(UDExGroupIndex).should("have.attr", "aria-label", `${UDExGroup.label} ${UDExGroup.supportingText}`);
+      UDExHeaderHost().eq(UDExGroupIndex).should("have.attr", "aria-expanded", "true");
+      UDExHeaderHost().eq(UDExGroupIndex).should("have.attr", "aria-selected", "false");
+
+      UDExGroup.countries.forEach((UDExCountry, UDExChildIndex) => {
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExLeafHost(UDExCountry), UDExChildIndex + 1, 3, 2);
+        UDExAssertLeafName(UDExLeafHost(UDExCountry), UDExCountry);
+        UDExLeafHost(UDExCountry).should("have.attr", "aria-selected", "false");
+        UDExAssertPresentationItem(UDExLeafHost(UDExCountry));
+      });
+    });
+
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+    cy.realPress("Enter");
+    UDExSourceLeaf("China").should("have.attr", "selected");
+    UDExLeafHost("China").should("have.attr", "aria-selected", "true");
+    UDExAssertSelectionEvent("China", ["China"]);
+    UDExPopover().should("not.have.attr", "open");
+    UDExCombobox().should("be.focused");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExAssertSelectionStatus("China", "Selected");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  // Updated: root and child positions are exposed only by one-based native host attributes.
+  it("counts top-level leaves and a group in native root positions while keeping children at level 2 and navigation silent", () => {
+    cy.mount(
+      <div id="select-box-regression-fixture">
+        <UDExSelectBox label="Country">
+          <UDExSelectBoxItem label="Worldwide"></UDExSelectBoxItem>
+          <UDExSelectBoxGroupHeader label="Europe" collapsible>
+            <UDExSelectBoxItem label="Germany"></UDExSelectBoxItem>
+            <UDExSelectBoxItem label="France"></UDExSelectBoxItem>
+          </UDExSelectBoxGroupHeader>
+          <UDExSelectBoxItem label="Other countries"></UDExSelectBoxItem>
+        </UDExSelectBox>
+      </div>
+    );
+    UDExOpenSelectBox(UDExLayouts[2]);
+    UDExAssertOpenWithActiveDescendant(UDExLeafHost("Worldwide"));
+    UDExAssertHostPosition(UDExLeafHost("Worldwide"), 1, 3, 1);
+    UDExAssertLeafName(UDExLeafHost("Worldwide"), "Worldwide");
+    UDExAssertHostSelection(UDExLeafHost("Worldwide"), false);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 2, 3, 1);
+    UDExHeaderHost().should("have.attr", "aria-label", "Europe");
+    UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("Germany"), 1, 2, 2);
+    UDExAssertHostSelection(UDExLeafHost("Germany"), false);
+    cy.realPress("End");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("Other countries"), 3, 3, 1);
+    UDExAssertLeafName(UDExLeafHost("Other countries"), "Other countries");
+    UDExAssertHostSelection(UDExLeafHost("Other countries"), false);
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  // Updated: navigation clears search counts while retaining the complete native highlighted group name.
+  it("preserves the space-joined highlighted group name with native positions and silent navigation", () => {
+    UDExMountCountrySelectBox();
+    UDExHeaderHost().first().should("have.attr", "aria-label", "Europe Available countries");
+    cy.realType("Europe");
+    UDExCombobox().should("have.value", "Europe");
+    UDExHeaderHost().should("have.length", 1);
+    UDExHeaderHost().should("have.attr", "aria-label", "Europe Available countries");
+    UDExHeaderHost().should("have.attr", "supporting-text", "Available countries");
+    UDExHeaderHost().find("[udex-list-item]").should("have.length", 3);
+    UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+    UDExStatus().should("have.length", 1).and("have.text", "4 results returned.");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+    UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    UDExHeaderHost().should("have.attr", "aria-label", "Europe Available countries");
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  // Updated: navigation clears result counts; filtered per-level positions and selection remain native.
+  it("retains filtering counts and recomputes native group and child positions with silent navigation", () => {
+    UDExMountCountrySelectBox();
+    cy.realType("an");
+    UDExCombobox().should("have.value", "an");
+    // Existing search counts include each matching group header as well as its enabled children.
+    UDExStatus().should("have.length", 1).and("have.text", "6 results returned.");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+    UDExHeaderHost().should("have.length", 2).each(($header, UDExGroupIndex) => {
+      UDExAssertHostPosition(cy.wrap($header), UDExGroupIndex + 1, 2, 1);
+      cy.wrap($header).find("[udex-list-item]").should("have.length", 2).each(($child, UDExChildIndex) => {
+        UDExAssertHostPosition(cy.wrap($child), UDExChildIndex + 1, 2, 2);
+        const UDExLabel = UDExGroupIndex === 0 ? ["Germany", "France"][UDExChildIndex] : ["Japan", "Jordan"][UDExChildIndex];
+        UDExAssertLeafName(cy.wrap($child), UDExLabel);
+        cy.wrap($child).should("have.attr", "aria-selected", "false");
+      });
+    });
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost().first(), 1, 2, 1);
+    UDExHeaderHost().first().should("have.attr", "aria-expanded", "true");
+    UDExAssertHostSelection(UDExHeaderHost().first(), false);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost().first().find("[udex-list-item]").first(), 1, 2, 2);
+
+    UDExCombobox().clear();
+    cy.realType("Japan");
+    UDExStatus().should("have.text", "2 results returned.");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+    UDExHeaderHost().should("have.length", 1);
+    UDExHeaderHost().should("have.attr", "aria-label", "Asia More destinations");
+    UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+    UDExHeaderHost().find("[udex-list-item]").should("have.length", 1);
+    UDExAssertHostPosition(UDExHeaderHost().find("[udex-list-item]"), 1, 1, 2);
+    UDExAssertLeafName(UDExHeaderHost().find("[udex-list-item]"), "Japan");
+    cy.realPress("End");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost().find("[udex-list-item]"), 1, 1, 2);
+    UDExAssertHostSelection(UDExHeaderHost().find("[udex-list-item]"), false);
+    UDExCombobox().should("have.value", "Japan");
+    cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  // Updated: filtered opening preserves exact counts; navigation clears them and retains native group metadata.
+  it("announces only search results when typing opens a closed dropdown, then updates counts on further input", () => {
+    UDExMountCountrySelectBox();
+    cy.realPress("Escape");
+    UDExPopover().should("not.have.attr", "open");
+    // The negative attribute assertion yields no attribute value; requery the element.
+    UDExPopover().then($popover => {
+      $popover[0].addEventListener("ui5-open", cy.stub().as("filteredPopoverOpened"), { once: true });
+    });
+    cy.realType("J");
+    cy.get("@filteredPopoverOpened").should("have.been.calledOnce");
+    UDExPopover().should("have.attr", "open");
+    UDExAssertSupplementalStatus("3 results returned.");
+    UDExCombobox().should("have.value", "J").and("be.focused");
+    UDExCombobox().should("have.attr", "aria-expanded", "true");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+    cy.realType("apan");
+    UDExStatus().should("have.text", "2 results returned.");
+    UDExCombobox().should("have.value", "Japan").and("be.focused");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExListHost().find("[_active-descendant]").should("not.exist");
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+    UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  // Updated: silent grouped End navigation is followed by exact no-matches status and cleared active identity.
+  it("reports no matches after silent grouped navigation without a stale active descendant or selection", () => {
+    UDExMountCountrySelectBox();
+    cy.realPress("End");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("China"), 3, 3, 2);
+    UDExAssertHostSelection(UDExLeafHost("China"), false);
+    cy.realType("zzznomatch");
+    UDExCombobox().should("have.value", "zzznomatch");
+    UDExStatus().should("have.length", 1).and("have.text", "No matches found.");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    cy.get("[udex-select-box]").shadow().find("[_active-descendant], [udex-list-group-header], [udex-list-item]").should("not.exist");
+    cy.get("[udex-select-box]").shadow().find(".udex-no-result").should("contain.text", "No matches found.");
+    cy.realPress("ArrowDown");
+    UDExStatus().should("have.text", "No matches found.");
+    UDExCombobox().should("be.focused");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExPopover().should("have.attr", "open");
+    cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  (["Escape", "Tab"] as const).forEach(UDExExitKey => {
+    // Updated: flat pointer opening announces expanded; subsequent footer navigation remains silent.
+    it(`keeps footer return navigation on the combobox and native option hosts without echo before ${UDExExitKey} exits`, () => {
+      UDExMountSelectBox(UDExListMode.SingleSelect, UDExLayouts[0], true);
+      // Unlike selection-change, close does not bubble to the surrounding fixture.
+      cy.get("[udex-select-box]").then($selectBox => {
+        $selectBox[0].addEventListener("close", cy.stub().as("dropdownClosed"));
+      });
+      cy.realPress("End");
+      UDExAssertSupplementalActiveDescendant(UDExLeafHost("Beta"), "");
+      UDExAssertHostPosition(UDExLeafHost("Beta"), 2, 3);
+      UDExAssertLeafName(UDExLeafHost("Beta"), "Beta");
+      UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+      cy.get("@comboboxBlur").should("not.have.been.called");
+
+      cy.realPress("Tab");
+      cy.get("#select-box-footer-action").should("be.focused");
+      UDExCombobox().should("not.have.attr", "aria-activedescendant");
+      UDExListHost().find("[_active-descendant]").should("not.exist");
+      UDExStatus().should("have.text", "");
+      UDExPopover().should("have.attr", "open");
+
+      cy.realPress(["Shift", "Tab"]);
+      UDExAssertSupplementalActiveDescendant(UDExLeafHost("Beta"), "");
+      UDExAssertHostPosition(UDExLeafHost("Beta"), 2, 3);
+      UDExAssertPresentationItem(UDExLeafHost("Beta"));
+      UDExLeafHost("Beta").should("not.be.focused");
+      UDExLeafHost("Beta").should("have.attr", "aria-selected", "false");
+      cy.realPress("ArrowUp");
+      UDExAssertSupplementalActiveDescendant(UDExLeafHost("Alpha"), "");
+      UDExAssertHostPosition(UDExLeafHost("Alpha"), 1, 3);
+      UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha");
+      cy.get("@comboboxBlur").should("have.been.calledOnce");
+
+      cy.realPress("Tab");
+      cy.get("#select-box-footer-action").should("be.focused");
+      cy.realPress(UDExExitKey);
+      UDExPopover().should("not.have.attr", "open");
+      UDExCombobox().should("have.attr", "aria-expanded", "false");
+      UDExCombobox().should("have.attr", "aria-label", "Languages");
+      UDExCombobox().should("not.have.attr", "aria-activedescendant");
+      UDExListHost().find("[_active-descendant]").should("not.exist");
+      UDExStatus().should("have.text", "");
+      if (UDExExitKey === "Escape") {
+        UDExCombobox().should("be.focused");
+      } else {
+        cy.get("#after-select-box").should("be.focused");
+      }
+      cy.get("@dropdownClosed").should("have.been.calledOnce");
+      cy.get("@selectionChange").should("not.have.been.called");
+      cy.get("[udex-select-box]").find("[udex-select-box-item][selected]").should("not.exist");
+    });
+  });
+
+  // Updated: selection retains full-name feedback; native Boolean state and partial descriptions replace live metadata.
+  it("separates MultiSelect selection feedback from silent navigation, including selection while collapsed", () => {
+    UDExMountSelectBox(UDExListMode.MultiSelect, UDExLayouts[2]);
+    UDExAssertOpenWithActiveDescendant(UDExHeaderHost(), "");
+    UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 3, 2);
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+    cy.realPress("Enter");
+    UDExSourceLeaf("Alpha").should("have.attr", "selected");
+    UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), true);
+    UDExAssertHostSelection(UDExHeaderHost(), false, true);
+    UDExAssertSelectionEvent("Alpha", ["Alpha"]);
+    UDExAssertActiveDescendant(UDExLeafHost("Alpha"));
+    UDExAssertSelectionStatus("Alpha", "Selected");
+
+    cy.realPress("Space");
+    UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    UDExAssertSelectionEvent("Alpha", [], 2);
+    UDExAssertActiveDescendant(UDExLeafHost("Alpha"));
+    UDExAssertSelectionStatus("Alpha", "Unselected");
+    cy.realPress("Home");
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+
+    cy.realPress("ArrowLeft");
+    UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+    cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("have.attr", "collapsed");
+    UDExHeaderHost().find("[udex-list-item]").each($item => {
+      cy.wrap($item).should("have.attr", "collapsed");
+    });
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+    cy.get("@selectionChange").should("have.callCount", 2);
+
+    cy.realPress("Enter");
+    UDExSourceLeaf("Alpha").should("have.attr", "selected");
+    UDExSourceLeaf("Beta").should("have.attr", "selected");
+    UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+    UDExAssertHostSelection(UDExHeaderHost(), false, true);
+    UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), true);
+    UDExAssertHostSelection(UDExLeafHost("Beta"), true);
+    UDExAssertHostSelection(UDExLeafHost("Unavailable"), false);
+    UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+    UDExAssertSelectionEvent("Languages group", ["Alpha", "Beta"], 3);
+    UDExAssertActiveDescendant(UDExHeaderHost());
+    UDExAssertSelectionStatus("Languages group", "Indeterminate");
+    UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+
+    cy.realPress("Space");
+    UDExSourceLeaf("Alpha").should("not.have.attr", "selected");
+    UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    UDExHeaderHost().should("have.attr", "aria-expanded", "false");
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+    UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+    UDExAssertSelectionEvent("Languages group", [], 4);
+    UDExAssertActiveDescendant(UDExHeaderHost());
+    UDExAssertSelectionStatus("Languages group", "Unselected");
+
+    cy.realPress("ArrowRight");
+    UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+    cy.get("[udex-select-box]").find("[udex-select-box-group-header]").should("not.have.attr", "collapsed");
+    UDExHeaderHost().find("[udex-list-item]").each($item => {
+      cy.wrap($item).should("not.have.attr", "collapsed");
+    });
+    UDExAssertNativeActiveDescendant(UDExHeaderHost(), 1, 1, 1);
+    UDExAssertPresentationItem(UDExNestedHeader());
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+    UDExAssertNativeHostStates();
+    UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+    cy.get("@selectionChange").should("have.callCount", 4);
+    cy.get("@comboboxBlur").should("not.have.been.called");
+    UDExPopover().should("have.attr", "open");
+  });
+});
+
+describe("SelectBox complete leaf names and explicit selection feedback", () => {
+  [UDExListMode.SingleSelect, UDExListMode.MultiSelect].forEach(UDExMode => {
+    UDExLayouts.forEach(UDExLayout => {
+      // Updated: full-name selection feedback persists; selected-child reopening keeps the popup fallback.
+      it(`announces the complete ${UDExMode} / ${UDExLayout.name} leaf name and new state without level or position`, () => {
+        const UDExItems = [
+          <UDExSelectBoxItem label="Alpha" supportingText="First choice" additionalText="Code A"></UDExSelectBoxItem>,
+          <UDExSelectBoxItem label="Beta" supportingText="Second choice" additionalText="Code B"></UDExSelectBoxItem>,
+        ];
+        cy.mount(
+          <div id="select-box-regression-fixture">
+            <UDExSelectBox label="Languages" supportingText="Choose a language" mode={UDExMode}>
+              {UDExLayout.grouped ? (
+                <UDExSelectBoxGroupHeader label="Languages group" supportingText="Available choices" collapsible={UDExLayout.collapsible}>
+                  {UDExItems}
+                </UDExSelectBoxGroupHeader>
+              ) : UDExItems}
+            </UDExSelectBox>
+          </div>
+        );
+        UDExOpenSelectBox(UDExLayout);
+        UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha", "First choice", "Code A");
+        UDExAssertLeafName(UDExLeafHost("Beta"), "Beta", "Second choice", "Code B");
+        cy.get("[udex-select-box]").then($host => {
+          $host[0].addEventListener("close", cy.stub().as("selectionClosed"));
+        });
+        cy.realPress("End");
+        UDExAssertNativeActiveDescendant(UDExLeafHost("Beta"), 2, 2, UDExLayout.grouped ? 2 : undefined);
+        UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+        UDExAssertDescription("Choose a language");
+        cy.realPress("Enter");
+        UDExSourceLeaf("Beta").should("have.attr", "selected");
+        UDExAssertSelectionEvent("Beta", ["Beta"]);
+        UDExAssertSelectionStatus("Beta Second choice Code B", "Selected");
+
+        if (UDExMode === UDExListMode.SingleSelect) {
+          cy.get("@selectionClosed").should("have.been.calledOnce");
+          UDExPopover().should("not.have.attr", "open");
+          UDExCombobox().should("have.attr", "aria-expanded", "false");
+          UDExCombobox().should("not.have.attr", "aria-activedescendant");
+          UDExListHost().find("[_active-descendant]").should("not.exist");
+          UDExAssertDescription("Choose a language Beta");
+          // Feedback survives the complete close lifecycle, not merely the initial selection handler.
+          UDExAssertSelectionStatus("Beta Second choice Code B", "Selected");
+          cy.realPress("ArrowDown");
+          UDExAssertOpenWithActiveDescendant(UDExLeafHost("Beta"), "expanded");
+          UDExAssertHostPosition(UDExLeafHost("Beta"), 2, 2, UDExLayout.grouped ? 2 : undefined);
+          UDExAssertHostSelection(UDExLeafHost("Beta"), true);
+          UDExAssertDescription("Choose a language");
+          UDExAssertSelectionEvent("Beta", ["Beta"]);
+          cy.realPress("ArrowDown");
+          UDExAssertNativeActiveDescendant(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"), 1,
+            UDExLayout.collapsible ? 1 : 2, UDExLayout.grouped ? UDExLayout.collapsible ? 1 : 2 : undefined);
+          if (UDExLayout.collapsible) {
+            UDExHeaderHost().should("have.attr", "aria-expanded", "true");
+          }
+          UDExAssertHostSelection(UDExLayout.collapsible ? UDExHeaderHost() : UDExLeafHost("Alpha"), false);
+          UDExAssertDescription("Choose a language");
+          UDExAssertSelectionEvent("Beta", ["Beta"]);
+        } else {
+          UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+          UDExAssertDescription("Choose a language");
+          cy.realPress("Space");
+          UDExSourceLeaf("Beta").should("not.have.attr", "selected");
+          UDExAssertSelectionEvent("Beta", [], 2);
+          UDExAssertSelectionStatus("Beta Second choice Code B", "Unselected");
+          UDExAssertDescription("Choose a language");
+          cy.realPress("ArrowUp");
+          UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, UDExLayout.grouped ? 2 : undefined);
+          UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+          cy.get("@selectionClosed").should("not.have.been.called");
+        }
+        UDExCombobox().should("be.focused");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+    });
+  });
+
+  [
+    { name: "supporting text", supportingText: "Unnamed choice", additionalText: "" },
+    { name: "additional text", supportingText: "", additionalText: "Choice code" },
+  ].forEach(UDExCase => {
+    // Updated: unnamed leaf opening supplements only expanded, not native item metadata.
+    it(`exposes ${UDExCase.name} as the host name when a leaf has no label`, () => {
+      cy.mount(
+        <div id="select-box-regression-fixture">
+          <UDExSelectBox accessibleName="Languages">
+            <UDExSelectBoxItem supportingText={UDExCase.supportingText} additionalText={UDExCase.additionalText}></UDExSelectBoxItem>
+          </UDExSelectBox>
+        </div>
+      );
+      UDExOpenSelectBox(UDExLayouts[0]);
+      const UDExName = UDExCase.supportingText || UDExCase.additionalText;
+      UDExListHost().find("[udex-list-item]").should("have.attr", "aria-label", UDExName);
+      UDExAssertActiveDescendant(UDExListHost().find("[udex-list-item]"));
+      UDExAssertOpeningStatus();
+      cy.realPress("Enter");
+      cy.get("[udex-select-box-item]").should("have.attr", "selected");
+      cy.get("[udex-select-box-item]").then($source => {
+        cy.get("@selectionChange").should("have.been.calledOnce")
+          .its("lastCall.args.0.detail").should((UDExDetail: UDExSearchableListBaseSelectionChangeEventDetail) => {
+            expect(UDExDetail.item).to.equal($source[0]);
+            expect(UDExDetail.selectedItems).to.deep.equal([$source[0]]);
+          });
+      });
+      UDExPopover().should("not.have.attr", "open");
+      UDExAssertSelectionStatus(UDExName, "Selected");
+      UDExCombobox().should("be.focused");
+      cy.get("@comboboxBlur").should("not.have.been.called");
+    });
+  });
+});
+
+describe("SelectBox same-shadow supporting descriptions", () => {
+  [UDExListMode.SingleSelect, UDExListMode.MultiSelect].forEach(UDExMode => {
+    [true, false].forEach(UDExVisibleLabel => {
+      it(`retains supporting text for ${UDExMode} with ${UDExVisibleLabel ? "a visible label" : "accessibleName only"} while suppressing navigation rereads`, () => {
+        cy.mount(
+          <div id="select-box-regression-fixture">
+            <UDExSelectBox label={UDExVisibleLabel ? "Languages" : undefined} accessibleName="Languages"
+              supportingText="Choose languages" mode={UDExMode}>
+              <UDExSelectBoxItem label="Alpha" selected></UDExSelectBoxItem>
+              <UDExSelectBoxItem label="Beta"></UDExSelectBoxItem>
+            </UDExSelectBox>
+          </div>
+        );
+        UDExCombobox().should("have.attr", "aria-label", "Languages");
+        cy.get("[udex-select-box]").shadow().find('label[for="search-input"]').should(UDExVisibleLabel ? "exist" : "not.exist");
+        if (UDExMode === UDExListMode.SingleSelect) {
+          UDExAssertDescription("Choose languages Alpha");
+        } else {
+          UDExAssertDescription("Choose languages", 1);
+        }
+        UDExOpenSelectBox(UDExLayouts[0]);
+        UDExAssertDescription("Choose languages");
+        cy.realPress("End");
+        UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+        UDExAssertDescription("Choose languages");
+        cy.realPress("Space");
+        UDExAssertSelectionEvent("Beta", UDExMode === UDExListMode.SingleSelect ? ["Beta"] : ["Alpha", "Beta"]);
+        UDExAssertSelectionStatus("Beta", "Selected");
+        if (UDExMode === UDExListMode.MultiSelect) {
+          // Token count changed, but the input description must not change during active navigation.
+          UDExAssertActiveDescendant(UDExLeafHost("Beta"));
+          UDExAssertDescription("Choose languages");
+          cy.realPress("Escape");
+          UDExPopover().should("not.have.attr", "open");
+          UDExAssertDescription("Choose languages", 2);
+          UDExAssertSupplementalStatus("");
+        } else {
+          UDExPopover().should("not.have.attr", "open");
+          UDExAssertDescription("Choose languages Beta");
+          UDExAssertSelectionStatus("Beta", "Selected");
+        }
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExCombobox().should("be.focused");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+    });
+  });
+});
+
+describe("SelectBox partial-selection description lifecycle", () => {
+  const UDExWindow = window as Window & { "udex-config"?: { translations?: Record<string, string> } };
+  let UDExOriginalConfig: typeof UDExWindow["udex-config"];
+
+  beforeEach(() => {
+    UDExOriginalConfig = UDExWindow["udex-config"];
+  });
+
+  afterEach(() => {
+    if (UDExOriginalConfig === undefined) {
+      delete UDExWindow["udex-config"];
+    } else {
+      UDExWindow["udex-config"] = UDExOriginalConfig;
+    }
+  });
+
+  [
+    { name: "Select All", selectAll: true, collapsible: false, description: "Indeterminate", localized: false },
+    { name: "localized Select All", selectAll: true, collapsible: false, description: "Teilweise ausgewählt", localized: true },
+    { name: "localized noncollapsible group", selectAll: false, collapsible: false, description: "Teilweise ausgewählt", localized: true },
+    { name: "localized collapsible group", selectAll: false, collapsible: true, description: "Teilweise ausgewählt", localized: true },
+  ].forEach(UDExCase => {
+    it(`exposes ${UDExCase.name} as partial, selected, then unselected with Boolean selection and exact description cleanup`, () => {
+      if (UDExCase.localized) {
+        // Use the supported translation override without changing global UI5 language or loading bundles.
+        UDExWindow["udex-config"] = {
+          ...UDExOriginalConfig,
+          translations: { ...UDExOriginalConfig?.translations, INDETERMINATE: UDExCase.description },
+        };
+      }
+      const UDExGroupName = "All languages Available choices";
+      const UDExHost = () => UDExCase.selectAll ? UDExSelectAllHost() : UDExHeaderHost();
+      const UDExSource = () => cy.get(UDExCase.selectAll ? "#select-all-source" : "#partial-group-source");
+      const UDExHeaderPosition = UDExCase.selectAll ? 2 : 1;
+      const UDExRootSize = UDExCase.selectAll ? 3 : 1;
+
+      if (UDExCase.selectAll) {
+        UDExMountSelectAll("All languages", "Available choices");
+        cy.realPress("ArrowDown");
+      } else {
+        cy.mount(
+          <div id="select-box-regression-fixture">
+            <UDExSelectBox accessibleName="Languages" supportingText="Choose languages" mode={UDExListMode.MultiSelect}>
+              <UDExSelectBoxGroupHeader id="partial-group-source" label="All languages" supportingText="Available choices"
+                collapsible={UDExCase.collapsible}>
+                <UDExSelectBoxItem label="Alpha" supportingText="First choice" additionalText="Code A"></UDExSelectBoxItem>
+                <UDExSelectBoxItem label="Beta" supportingText="Second choice" additionalText="Code B"></UDExSelectBoxItem>
+              </UDExSelectBoxGroupHeader>
+            </UDExSelectBox>
+          </div>
+        );
+        UDExOpenSelectBox(UDExLayouts[UDExCase.collapsible ? 2 : 1]);
+        // Updated: only the expanded collapsible header suppresses the opening fallback.
+        UDExAssertOpenWithActiveDescendant(UDExHost(), UDExCase.collapsible ? "" : "expanded");
+        // Start navigation to clear opening feedback before testing the partial state.
+        cy.realPress("Home");
+      }
+      UDExAssertNativeActiveDescendant(UDExHost(), UDExHeaderPosition, UDExRootSize, 1);
+      UDExAssertHostSelection(UDExHost(), false);
+      UDExHost().then($originalHeader => {
+        UDExSource().then($source => {
+          UDExCombobox().then($input => {
+            const UDExOriginalInput = $input[0];
+            const UDExAssertHeaderIdentity = () => {
+              UDExHost().should($current => {
+                expect($current[0], "partial selection does not replace the header").to.equal($originalHeader[0]);
+                expect($current).to.have.attr("aria-label", UDExGroupName);
+                if (UDExCase.collapsible) {
+                  expect($current).to.have.attr("aria-expanded", "true");
+                } else {
+                  expect($current).not.to.have.attr("aria-expanded");
+                }
+              });
+              UDExSource().should($current => expect($current[0]).to.equal($source[0]));
+              UDExCombobox().should($current => expect($current[0]).to.equal(UDExOriginalInput));
+              UDExAssertHostPosition(UDExHost(), UDExHeaderPosition, UDExRootSize, 1);
+              UDExAssertNativeHostStates();
+              cy.get("@comboboxBlur").should("not.have.been.called");
+            };
+
+            cy.realPress("ArrowDown");
+            UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, 2);
+            cy.realPress("Enter");
+            UDExAssertSelectionEvent("Alpha", ["Alpha"]);
+            UDExSourceLeaf("Alpha").then($leaf => {
+              cy.get("@selectionChange").its("lastCall.args.0.detail.item").should("equal", $leaf[0]);
+            });
+            UDExAssertSelectionStatus("Alpha First choice Code A", "Selected");
+            UDExAssertHostSelection(UDExLeafHost("Alpha"), true);
+            UDExAssertHostSelection(UDExLeafHost("Beta"), false);
+            UDExAssertHostSelection(UDExHost(), false, true, UDExCase.description);
+            UDExSource().should("have.prop", "selected", true);
+            UDExSource().should("have.prop", "indeterminate", true);
+            UDExAssertHeaderIdentity();
+
+            cy.realPress("ArrowUp");
+            UDExAssertNativeActiveDescendant(UDExHost(), UDExHeaderPosition, UDExRootSize, 1);
+            // Partial description remains native on re-entry; neither it nor Selected is repeated live.
+            UDExAssertHostSelection(UDExHost(), false, true, UDExCase.description);
+            [true, false].forEach((UDExSelected, UDExIndex) => {
+              cy.realPress(UDExSelected ? "Enter" : "Space");
+              UDExAssertHostSelection(UDExHost(), UDExSelected);
+              UDExSource().should("have.prop", "selected", UDExSelected);
+              UDExSource().should("have.prop", "indeterminate", false);
+              ["Alpha", "Beta"].forEach(UDExLabel => {
+                UDExSourceLeaf(UDExLabel).should(UDExSelected ? "have.attr" : "not.have.attr", "selected");
+                UDExAssertHostSelection(UDExLeafHost(UDExLabel), UDExSelected);
+              });
+              UDExAssertActiveDescendant(UDExHost());
+              UDExAssertSelectionStatus(UDExGroupName, UDExSelected ? "Selected" : "Unselected");
+              if (UDExCase.selectAll) {
+                cy.get("@selectAll").should("have.callCount", UDExIndex + 1).its("lastCall.args.0").should((UDExEvent: Event) => {
+                  expect(UDExEvent.type).to.equal("select-all");
+                  expect(UDExEvent.bubbles).to.equal(true);
+                });
+                cy.get("@routedSelectAll").should("have.callCount", UDExIndex + 1)
+                  .its("lastCall.args.0.detail.item").should("equal", $originalHeader[0]);
+                cy.get("@wrongHeaderPress").should("not.have.been.called");
+                UDExAssertSelectionEvent("Alpha", ["Alpha"]);
+                UDExSourceLeaf("Worldwide").should("not.have.attr", "selected");
+                UDExSourceLeaf("Other languages").should("not.have.attr", "selected");
+              } else {
+                UDExAssertSelectionEvent("All languages", UDExSelected ? ["Alpha", "Beta"] : [], UDExIndex + 2);
+                cy.get("@selectionChange").its("lastCall.args.0.detail.item").should("equal", $source[0]);
+              }
+              UDExAssertHeaderIdentity();
+              UDExAssertDescription("Choose languages");
+              UDExPopover().should("have.attr", "open");
+            });
+            cy.realPress("ArrowDown");
+            UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, 2);
+            UDExAssertHostSelection(UDExHost(), false);
+          });
+        });
+      });
+    });
+  });
+
+  it("removes a partial group's description outside MultiSelect and omits selection entirely in SingleContent", () => {
+    UDExMountSelectBox(UDExListMode.MultiSelect, UDExLayouts[2]);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 3, 2);
+    cy.realPress("Enter");
+    UDExAssertSelectionEvent("Alpha", ["Alpha"]);
+    UDExAssertHostSelection(UDExHeaderHost(), false, true);
+    cy.get("[udex-select-box]").invoke("prop", "mode", UDExListMode.SingleSelect);
+    UDExAssertHostSelection(UDExHeaderHost(), false);
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), true);
+    UDExAssertHostPosition(UDExHeaderHost(), 1, 1, 1);
+    cy.get("[udex-select-box]").invoke("prop", "mode", UDExListMode.SingleContent);
+    UDExListHost().find("[udex-list-group-header], [udex-list-item]").should($hosts => {
+      expect($hosts).to.have.length(4);
+      $hosts.each((UDExIndex, UDExHost) => {
+        expect(UDExHost, `informational host ${UDExIndex}`).not.to.have.attr("aria-selected");
+        expect(UDExHost).not.to.have.attr("aria-checked");
+        expect(UDExHost).not.to.have.attr("aria-description");
+      });
+    });
+    UDExSourceLeaf("Alpha").should("have.attr", "selected");
+    cy.get("@selectionChange").should("have.been.calledOnce");
+    UDExCombobox().should("be.focused");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+});
+
+describe("SelectBox unified Select All host architecture", () => {
+  [
+    { name: "translated default", label: undefined, supportingText: undefined, accessibleName: "Select All" },
+    { name: "custom label and support", label: "All languages", supportingText: "Available choices", accessibleName: "All languages Available choices" },
+  ].forEach(UDExCase => {
+    describe(UDExCase.name, () => {
+      beforeEach(() => {
+        UDExMountSelectAll(UDExCase.label, UDExCase.supportingText);
+      });
+
+      // Updated: Select All owns Boolean selection and native positions; opening is expanded-only and navigation silent.
+      it("owns one stable named level-1 treeitem and presents its wrappers and inner row without duplicate widgets", () => {
+        UDExCombobox().should("have.attr", "aria-haspopup", "tree");
+        UDExListHost().should("have.attr", "role", "tree");
+        cy.get("#select-all-source").then($source => {
+          const UDExId = ($source[0] as UDExSelectBoxSelectAllElement)._id;
+          UDExSelectAllHost().should("have.attr", "id", UDExId).and("have.attr", "data-token-id", UDExId);
+        });
+        UDExAssertHostPosition(UDExSelectAllHost(), 2, 3, 1);
+        UDExSelectAllHost().should($host => {
+          expect($host).to.have.attr("aria-label", UDExCase.accessibleName);
+          expect($host).to.have.attr("aria-selected", "false");
+          expect($host).to.have.attr("_use-host-aria-role");
+          expect($host).to.have.attr("_tree-mode");
+          expect($host).not.to.have.attr("aria-checked");
+          expect($host).not.to.have.attr("aria-description");
+          expect($host).not.to.have.attr("aria-expanded");
+          expect($host).not.to.have.attr("tabindex");
+        });
+        UDExSelectAllHost().shadow().find('[part="item"], .udex-list__group-list').should("have.length", 2).each($wrapper => {
+          cy.wrap($wrapper).should($element => {
+            expect($element).to.have.attr("role", "presentation");
+            ["aria-label", "aria-labelledby", ...UDExInnerStateAttributes].forEach(UDExAttribute => {
+              expect($element).not.to.have.attr(UDExAttribute);
+            });
+          });
+        });
+        UDExSelectAllHost().shadow().find('[role="treeitem"], [role="option"], [role="listbox"]').should("not.exist");
+        UDExSelectAllHost().shadow().find('div[role="group"] > slot').should("have.length", 1);
+        UDExSelectAllRow().should($row => {
+          expect($row).to.have.attr("role", "none");
+          expect($row).to.have.attr("_use-host-aria-role");
+          [...UDExInnerStateAttributes, "aria-current"].forEach(UDExAttribute => {
+            expect($row).not.to.have.attr(UDExAttribute);
+          });
+        });
+        UDExAssertPresentationItem(UDExSelectAllRow());
+        UDExSelectAllRow().shadow().find('[part="title"]').should("have.text", UDExCase.label || "Select All");
+        if (UDExCase.supportingText) {
+          UDExSelectAllRow().shadow().find('[part="supporting"]').should("have.text", UDExCase.supportingText);
+        }
+        UDExAssertHostPosition(UDExLeafHost("Alpha"), 1, 2, 2);
+        UDExAssertHostPosition(UDExLeafHost("Beta"), 2, 2, 2);
+        UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha", "First choice", "Code A");
+        UDExAssertLeafName(UDExLeafHost("Beta"), "Beta", "Second choice", "Code B");
+        ["Alpha", "Beta"].forEach(UDExLabel => {
+          UDExAssertHostSelection(UDExLeafHost(UDExLabel), false);
+          UDExLeafHost(UDExLabel).should("not.have.attr", "aria-expanded");
+          UDExAssertPresentationItem(UDExLeafHost(UDExLabel));
+        });
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 2, 3, 1);
+        cy.realPress("Escape");
+        UDExPopover().should("not.have.attr", "open");
+        UDExCombobox().should("have.attr", "aria-expanded", "false");
+        UDExCombobox().should("not.have.attr", "aria-activedescendant");
+        UDExListHost().find("[_active-descendant]").should("not.exist");
+        UDExAssertSupplementalStatus("");
+        UDExCombobox().should("be.focused");
+        cy.realPress("ArrowDown");
+        UDExAssertOpenWithActiveDescendant(UDExLeafHost("Worldwide"));
+        UDExAssertHostPosition(UDExLeafHost("Worldwide"), 1, 3, 1);
+        cy.realPress("ArrowDown");
+        UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 2, 3, 1);
+        cy.get("#select-all-source").then($source => {
+          UDExSelectAllHost().should("have.attr", "id", ($source[0] as UDExSelectBoxSelectAllElement)._id);
+        });
+        cy.get("@selectAll").should("not.have.been.called");
+        cy.get("@selectionChange").should("not.have.been.called");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+
+      (["Enter", "Space", "pointer"] as const).forEach(UDExActivation => {
+        // Updated: Select All toggles native Boolean selection and removes any partial description.
+        it(`routes ${UDExActivation} through select-all exactly once per toggle and announces the new header state without blurring`, () => {
+          cy.realPress("ArrowDown");
+          UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 2, 3, 1);
+          [true, false].forEach((UDExSelected, UDExIndex) => {
+            if (UDExActivation === "pointer") {
+              UDExSelectAllRow().shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+            } else {
+              cy.realPress(UDExActivation);
+            }
+            ["Alpha", "Beta"].forEach(UDExLabel => {
+              UDExSourceLeaf(UDExLabel).should(UDExSelected ? "have.attr" : "not.have.attr", "selected");
+              UDExAssertHostSelection(UDExLeafHost(UDExLabel), UDExSelected);
+            });
+            UDExAssertHostSelection(UDExSelectAllHost(), UDExSelected);
+            cy.get("#select-all-source").should("have.prop", "selected", UDExSelected);
+            cy.get("#select-all-source").should("have.prop", "indeterminate", false);
+            UDExSelectAllHost().should("not.have.attr", "aria-expanded");
+            UDExAssertActiveDescendant(UDExSelectAllHost());
+            UDExAssertSelectionStatus(UDExCase.accessibleName, UDExSelected ? "Selected" : "Unselected");
+            UDExAssertDescription("Choose languages");
+            UDExAssertSelectAllEvent(UDExIndex + 1);
+            UDExSourceLeaf("Worldwide").should("not.have.attr", "selected");
+            UDExSourceLeaf("Other languages").should("not.have.attr", "selected");
+            UDExAssertPresentationItem(UDExSelectAllRow());
+            UDExCombobox().should("be.focused");
+            cy.get("@comboboxBlur").should("not.have.been.called");
+          });
+          cy.realPress("ArrowDown");
+          UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, 2);
+          UDExAssertSelectAllEvent(2);
+        });
+      });
+    });
+  });
+
+  // Updated: partial Select All is false with Indeterminate description, which is removed after deselection.
+  it("describes partial Select All when a disabled child remains unselected, then removes the description when unselected", () => {
+    UDExMountSelectAll("All languages", "Available choices", true);
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 2, 3, 1);
+    cy.realPress("Space");
+    UDExAssertSelectAllEvent(1);
+    UDExAssertHostSelection(UDExSelectAllHost(), false, true);
+    cy.get("#select-all-source").should("have.prop", "indeterminate", true);
+    UDExAssertActiveDescendant(UDExSelectAllHost());
+    UDExAssertSelectionStatus("All languages Available choices", "Indeterminate");
+    ["Alpha", "Beta"].forEach(UDExLabel => UDExSourceLeaf(UDExLabel).should("have.attr", "selected"));
+    UDExSourceLeaf("Unavailable").should("not.have.attr", "selected");
+    UDExAssertHostSelection(UDExLeafHost("Unavailable"), false);
+    UDExLeafHost("Unavailable").should("have.attr", "aria-disabled", "true");
+    UDExSelectAllRow().shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+    UDExAssertSelectAllEvent(2);
+    UDExAssertHostSelection(UDExSelectAllHost(), false);
+    UDExAssertActiveDescendant(UDExSelectAllHost());
+    cy.get("#select-all-source").should("have.prop", "indeterminate", false);
+    UDExAssertSelectionStatus("All languages Available choices", "Unselected");
+    ["Alpha", "Beta", "Unavailable"].forEach(UDExLabel => UDExSourceLeaf(UDExLabel).should("not.have.attr", "selected"));
+    UDExAssertDescription("Choose languages");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+
+  (["pointer", "keyboard"] as const).forEach(UDExActivation => {
+    // Updated: leaf selection remains Boolean; partial Select All description is added and cleaned up.
+    it(`keeps complete child names and selection-change payloads for ${UDExActivation} leaf toggles inside Select All`, () => {
+      UDExMountSelectAll();
+      cy.realPress("ArrowDown");
+      cy.realPress("ArrowDown");
+      UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, 2);
+      [true, false].forEach((UDExSelected, UDExIndex) => {
+        if (UDExActivation === "pointer") {
+          UDExLeafHost("Alpha").shadow().find('[part="item"]').realClick({ scrollBehavior: false });
+        } else {
+          cy.realPress(UDExSelected ? "Space" : "Enter");
+        }
+        UDExAssertSelectionEvent("Alpha", UDExSelected ? ["Alpha"] : [], UDExIndex + 1);
+        UDExSourceLeaf("Alpha").should(UDExSelected ? "have.attr" : "not.have.attr", "selected");
+        UDExAssertHostSelection(UDExLeafHost("Alpha"), UDExSelected);
+        UDExAssertHostSelection(UDExSelectAllHost(), false, UDExSelected);
+        UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha", "First choice", "Code A");
+        UDExAssertActiveDescendant(UDExLeafHost("Alpha"));
+        UDExAssertSelectionStatus("Alpha First choice Code A", UDExSelected ? "Selected" : "Unselected");
+        UDExAssertDescription("Choose languages");
+        UDExAssertPresentationItem(UDExLeafHost("Alpha"));
+        cy.get("@selectAll").should("not.have.been.called");
+        cy.get("@routedSelectAll").should("not.have.been.called");
+        cy.get("@comboboxBlur").should("not.have.been.called");
+      });
+      cy.realPress("ArrowUp");
+      UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 2, 3, 1);
+      UDExSelectAllHost().should("not.have.attr", "aria-expanded");
+    });
+  });
+
+  // Updated: highlighted native positions remain exact while navigation clears the live status.
+  it("keeps highlighted Select All and leaf host names clean while recomputing root and child positions", () => {
+    UDExMountSelectAll("All languages", "Available choices");
+    cy.realType("All languages");
+    UDExCombobox().should("not.have.attr", "aria-activedescendant");
+    UDExSelectAllHost().should("have.attr", "aria-label", "All languages Available choices");
+    UDExAssertHostPosition(UDExSelectAllHost(), 1, 1, 1);
+    UDExSelectAllRow().shadow().find('[part="title"] b').should("have.text", "All languages");
+    UDExAssertLeafName(UDExLeafHost("Alpha"), "Alpha", "First choice", "Code A");
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExSelectAllHost(), 1, 1, 1);
+    UDExAssertHostSelection(UDExSelectAllHost(), false);
+    UDExSelectAllHost().should("not.have.attr", "aria-expanded");
+    cy.realPress("ArrowDown");
+    UDExAssertNativeActiveDescendant(UDExLeafHost("Alpha"), 1, 2, 2);
+    UDExAssertHostSelection(UDExLeafHost("Alpha"), false);
+    cy.get("@selectionChange").should("not.have.been.called");
+    cy.get("@selectAll").should("not.have.been.called");
+    cy.get("@comboboxBlur").should("not.have.been.called");
+  });
+});