dimsum-e2e-tests 3.70.0-next.63 → 3.70.0-next.69

package/CHANGELOG.md

@@ -3,6 +3,42 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 3.70.0-next.69 (2026-08-27)
+
+### Bug Fixes
+
+- ds-form-date-range-picker:: add picker callback E2E coverage [PUI-18907](https://jira.elliemae.io/browse/PUI-18907) ([#8343](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8343)) ([74b1724](https://github.com/intcx/PLATFORM-UI.dimsum/commit/74b1724d92c8bc91ee2fdb9106237da382dea311))
+
+## 3.70.0-next.68 (2026-08-26)
+
+### Bug Fixes
+
+- ds-pills-v2:: pitfalls label requirement disclaimer and input/error association [PUI-18617](https://jira.elliemae.io/browse/PUI-18617) ([#8335](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8335)) ([050fb4b](https://github.com/intcx/PLATFORM-UI.dimsum/commit/050fb4b91cfc8292f9d7474cbb6c0496d5205661))
+
+## 3.70.0-next.67 (2026-08-26)
+
+### Bug Fixes
+
+- ds-global-header:: restored unintentional test-id change to usual one [PUI-19020](https://jira.elliemae.io/browse/PUI-19020) ([#8337](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8337)) ([149cc79](https://github.com/intcx/PLATFORM-UI.dimsum/commit/149cc797c44bf15f3723ec7a19d73311755bf471))
+
+## 3.70.0-next.66 (2026-08-26)
+
+### Features
+
+- ds-global-header:: E2E coverage for toolbar item contract passthrough [PUI-18647](https://jira.elliemae.io/browse/PUI-18647) ([#8332](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8332)) ([ad4a2bb](https://github.com/intcx/PLATFORM-UI.dimsum/commit/ad4a2bbb5027f343605cfd164fe5d6265ebd6e9e))
+
+## 3.70.0-next.65 (2026-08-25)
+
+### Bug Fixes
+
+- ds-form-date-range-picker:: forward props onPickerOpen and onPickerClose to the calendar [PUI-18907](https://jira.elliemae.io/browse/PUI-18907) ([#8334](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8334)) ([dbbe29c](https://github.com/intcx/PLATFORM-UI.dimsum/commit/dbbe29cabefa96a848441565d4e14a6c94e99bac))
+
+## 3.70.0-next.64 (2026-08-25)
+
+### Features
+
+- dimsum:: stories as correct typechecked deliverables [PUI-18610](https://jira.elliemae.io/browse/PUI-18610) ([#8331](https://github.com/intcx/PLATFORM-UI.dimsum/issues/8331)) ([2c4da4c](https://github.com/intcx/PLATFORM-UI.dimsum/commit/2c4da4cda51ce2a4b4e597926f257d144c1494f1))
+
 ## 3.70.0-next.63 (2026-08-22)
 
 **Note:** Version bump only for package dimsum-e2e-tests

package/ds-apppicker/DSAppPickerCO.js

@@ -18,6 +18,13 @@ export default class DSAppPickerCO extends PageObject {
 
   static reflowURL = new Urlbuilder(`${PATH_E2E_APP_PICKER}`, 'reflow-test');
 
+  // PUI-18647 — the two custom-trigger APIs side by side. Storybook kebab-cases the
+  // `PUI18647CustomTriggers...` export with a hyphen after the prefix, hence `pui-18647`.
+  static customTriggerFocusURL = new Urlbuilder(
+    `${PATH_E2E_APP_PICKER}`,
+    'pui-18647-custom-triggers-focus-parity-with-deprecated',
+  );
+
   // Snapshots
   static snapshotPath(example = 'basic') {
     return PageObject.getSnapshotPathBuilder('AppPicker', example);
@@ -136,6 +143,20 @@ export default class DSAppPickerCO extends PageObject {
     return (await element.getAttribute('aria-current')) === 'true';
   }
 
+  // PUI-18647 selectors
+
+  // The supported API: DSAppPicker hands the trigger renderer `innerRef` plus the internal handlers,
+  // so it can drive the first-app/selected-app focus logic on open.
+  static async getSupportedCustomTrigger() {
+    return $('[data-testid="pui18647-trigger-component"]');
+  }
+
+  // The deprecated API: `renderTrigger` receives only `ref`, so it cannot reach those handlers. It
+  // keeps its pre-existing behaviour by design — this is not a bug, it is the documented delta.
+  static async getDeprecatedCustomTrigger() {
+    return $('[data-testid="pui18647-render-trigger"]');
+  }
+
   // Slots
 
   static async getItemSlotByIndex(index = 0) {

package/ds-apppicker/custom-trigger-focus/DSAppPicker.custom-trigger-focus.func.spec.js

@@ -0,0 +1,82 @@
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+
+// Tests for the change introduced in PUI-18647 (GlobalHeader -> DSAppPicker contract passthrough).
+// Widening the hand-off meant a consumer can finally supply a custom trigger, which exposed two
+// different focus stories that now need pinning:
+//
+//  - `TriggerComponent` (supported) receives `innerRef` AND the internal open handlers, so a keyboard
+//    open can run the selected-app focus logic and land on the selected chip.
+//  - `renderTrigger` (deprecated) receives only `ref`, so it cannot reach those handlers and falls
+//    back to focusing the panel on every path. Unchanged by design.
+//
+// The mouse path is the RE-BASELINE: a TriggerComponent picker opened with the mouse used to land on
+// the FIRST app and now lands on the panel, matching the built-in trigger. Kept on the full browser
+// matrix because pointer-driven focus is exactly where engines disagree.
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-19014 - DSAppPicker:: custom trigger open focus destinations - Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.customTriggerFocusURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: should focus the panel when the supported trigger is opened with the mouse', async () => {
+      const trigger = await DSAppPickerCO.getSupportedCustomTrigger();
+      await trigger.waitForDisplayed();
+      await trigger.click();
+
+      const panel = await DSAppPickerCO.getAppPickerRoot();
+      await panel.waitForDisplayed();
+      await expect(panel).toBeFocused();
+    });
+
+    it('02: should focus the selected app when the supported trigger is opened with Enter', async () => {
+      // Escape closes the panel opened in 01 and returns focus to the trigger, which is also the
+      // starting state this case needs.
+      await browser.keys(Key.Escape);
+      const trigger = await DSAppPickerCO.getSupportedCustomTrigger();
+      await expect(trigger).toBeFocused();
+
+      await browser.keys(Key.Enter);
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed();
+
+      // 'Reports' is deliberately the third app, so "landed on the selected app" cannot be mistaken
+      // for "landed on the first app".
+      const selectedChip = await DSAppPickerCO.getChipByLabel('Reports');
+      await expect(selectedChip).toBeFocused();
+      await expect(await DSAppPickerCO.isSelected(selectedChip)).toBe(true);
+    });
+
+    it('03: should focus the panel when the deprecated trigger is opened with the mouse', async () => {
+      await browser.keys(Key.Escape);
+
+      const trigger = await DSAppPickerCO.getDeprecatedCustomTrigger();
+      await trigger.waitForDisplayed();
+      await trigger.click();
+
+      const panel = await DSAppPickerCO.getAppPickerRoot();
+      await panel.waitForDisplayed();
+      await expect(panel).toBeFocused();
+    });
+
+    it('04: should focus the panel when the deprecated trigger is opened with Enter', async () => {
+      // The panel 03 left open is controlled from the story and has no Escape handler, so it is
+      // dismissed by clicking its trigger again. Where a dismissal click leaves focus is NOT what
+      // this case is about and is not consistent across engines — clicking a <button> does not focus
+      // it on macOS, and the panel unmounting mid-click can blur. So the keyboard starting state is
+      // established explicitly instead of being inherited from the click.
+      const trigger = await DSAppPickerCO.getDeprecatedCustomTrigger();
+      await trigger.click();
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed({ reverse: true });
+
+      await browser.execute((el) => el.focus(), trigger);
+      await expect(trigger).toBeFocused();
+
+      await browser.keys(Key.Enter);
+
+      const panel = await DSAppPickerCO.getAppPickerRoot();
+      await panel.waitForDisplayed();
+      await expect(panel).toBeFocused();
+    });
+  });
+}

package/ds-apppicker/label-expansion-dismissal/DSAppPicker.label-expansion-dismissal.visual.spec.js

@@ -0,0 +1,108 @@
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  const PARKED_X = 10;
+  const PARKED_Y = 10;
+
+  // Enabled and long enough to truncate. Chip 1 of the apps list is used rather than the first one,
+  // which is natively disabled and tracked separately under PUI-18981.
+  const TRUNCATING_CHIP = 'Pipeline but with a really long label that will truncate';
+
+  const ARIA_DISABLED_CHIP = 'Dashboard but with a really long label that will truncate';
+
+  describe('PUI-18986 - DSAppPicker:: Escape dismisses the expanded chip label - Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+      await DSAppPickerCO.openPanel();
+    });
+
+    it('01: truncated chip expands its label on hover', async () => {
+      await mouseOver(await DSAppPickerCO.getChipByLabel(TRUNCATING_CHIP));
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-hover-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('02: Escape collapses the hover-expanded label and keeps the panel open', async () => {
+      await browser.keys(Key.Escape);
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-hover-collapsed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('03: label expands again once the pointer leaves and returns', async () => {
+      await mouseOver(null, PARKED_X, PARKED_Y);
+      await mouseOver(await DSAppPickerCO.getChipByLabel(TRUNCATING_CHIP));
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-rehover-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('04: truncated chip expands its label on focus alone', async () => {
+      await mouseOver(null, PARKED_X, PARKED_Y);
+      await browser.keys(Key.Tab);
+      await expect(await DSAppPickerCO.getChipByLabel(TRUNCATING_CHIP)).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-focus-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('05: Escape collapses the focus-expanded label without moving focus', async () => {
+      await browser.keys(Key.Escape);
+      await expect(await DSAppPickerCO.getChipByLabel(TRUNCATING_CHIP)).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-focus-collapsed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('06: a further Escape closes the panel once the label is collapsed', async () => {
+      await browser.keys(Key.Escape);
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed({ reverse: true });
+      const snapshot = await browser.percyCheckScreenshot(DSAppPickerCO.snapshotPath('esc-dismiss-panel-closed'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+
+  describe('PUI-18987 - DSAppPicker:: Escape dismisses the expanded aria-disabled chip label - Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.applyAriaDisabledURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+      await DSAppPickerCO.openPanel();
+    });
+
+    it('01: aria-disabled truncated chip expands its label on hover', async () => {
+      await mouseOver(await DSAppPickerCO.getChipByLabel(ARIA_DISABLED_CHIP));
+      const snapshot = await browser.percyCheckScreenshot(
+        DSAppPickerCO.snapshotPath('aria-disabled-esc-dismiss-hover-expanded'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('02: Escape collapses the hover-expanded label and keeps the panel open', async () => {
+      await browser.keys(Key.Escape);
+      const snapshot = await browser.percyCheckScreenshot(
+        DSAppPickerCO.snapshotPath('aria-disabled-esc-dismiss-hover-collapsed'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('03: aria-disabled truncated chip expands its label on keyboard focus', async () => {
+      await mouseOver(null, PARKED_X, PARKED_Y);
+      await browser.keys(Key.Tab);
+      await expect(await DSAppPickerCO.getChipByLabel(ARIA_DISABLED_CHIP)).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(
+        DSAppPickerCO.snapshotPath('aria-disabled-esc-dismiss-focus-expanded'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('04: Escape collapses the focus-expanded label without moving focus', async () => {
+      await browser.keys(Key.Escape);
+      await expect(await DSAppPickerCO.getChipByLabel(ARIA_DISABLED_CHIP)).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(
+        DSAppPickerCO.snapshotPath('aria-disabled-esc-dismiss-focus-collapsed'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-chip/label-expansion-dismissal/DSChip.label-expansion-dismissal.visual.spec.js

@@ -0,0 +1,84 @@
+import { Key } from 'webdriverio';
+import DSChipCO from '../DSChipCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  const PARKED_X = 10;
+  const PARKED_Y = 10;
+
+  // Indexes into the basic-test story grid:
+  // 0 Large | 1 Small | 2 Selected | 3 Truncated with large label | 4 Disabled | 5 wrapText with large label
+  const TRUNCATING_CHIP = 3;
+  const WRAP_TEXT_CHIP = 5;
+
+  // DSChipCO deliberately has no label lookup, so the tab target is reached by walking the tab order.
+  // The natively disabled chip drops out of it on its own, which keeps this independent of the story's
+  // exact number of focus stops.
+  const MAX_TAB_STOPS = 12;
+  const tabUntilFocused = async (index) => {
+    const target = await DSChipCO.getChipButtonByIndex(index);
+    for (let i = 0; i < MAX_TAB_STOPS; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      if (await target.isFocused()) return target;
+      // eslint-disable-next-line no-await-in-loop
+      await browser.keys(Key.Tab);
+    }
+    throw new Error(`chip ${index} never took focus within ${MAX_TAB_STOPS} tab stops`);
+  };
+
+  describe('PUI-19009 - DSChip:: Escape dismisses the expanded truncated chip label - Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSChipCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+      await (await DSChipCO.getChipByIndex(TRUNCATING_CHIP)).waitForDisplayed();
+    });
+
+    it('01: truncated chip expands its label on hover', async () => {
+      await mouseOver(await DSChipCO.getChipByIndex(TRUNCATING_CHIP));
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-hover-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('02: Escape collapses the hover-expanded label without moving the pointer', async () => {
+      await browser.keys(Key.Escape);
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-hover-collapsed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('03: label stays collapsed while the pointer remains on the chip', async () => {
+      await mouseOver(await DSChipCO.getChipByIndex(TRUNCATING_CHIP), 12, 12);
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-hover-still-collapsed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('04: label expands again once the pointer leaves and returns', async () => {
+      await mouseOver(null, PARKED_X, PARKED_Y);
+      await mouseOver(await DSChipCO.getChipByIndex(TRUNCATING_CHIP));
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-rehover-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('05: truncated chip expands its label on focus alone', async () => {
+      await mouseOver(null, PARKED_X, PARKED_Y);
+      const chipButton = await tabUntilFocused(TRUNCATING_CHIP);
+      await expect(chipButton).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-focus-expanded'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('06: Escape collapses the focus-expanded label without moving focus', async () => {
+      await browser.keys(Key.Escape);
+      await expect(await DSChipCO.getChipButtonByIndex(TRUNCATING_CHIP)).toBeFocused();
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-focus-collapsed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('07: a wrapText chip never expands, so Escape leaves it untouched', async () => {
+      await mouseOver(await DSChipCO.getChipByIndex(WRAP_TEXT_CHIP));
+      await browser.keys(Key.Escape);
+      const snapshot = await browser.percyCheckScreenshot(DSChipCO.snapshotPath('esc-dismiss-wrap-text-unchanged'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-form-date-range-picker/DateRangePickerCO.js

@@ -30,6 +30,8 @@ export default class DateRangePickerCO extends PageObject {
     'apply-aria-disabled-invalid-selection-test',
   );
 
+  static pickerCallbacks = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_DATE_RANGE_PICKER, 'picker-callbacks-test');
+
   // Story elements
 
   static getNextMonthBtn = async () => $('[data-testid="ds-controlled-date-time-picker-calendar-next-month"]');
@@ -68,6 +70,10 @@ export default class DateRangePickerCO extends PageObject {
   static getClearableByIndex = async (index = 0) =>
     $$(`[data-testid="ds-controlled-date-time-picker-clear-btn"]`)[index];
 
+  static getOpenCallbackCount = async () => $('[data-testid="picker-open-count"]');
+
+  static getCloseCallbackCount = async () => $('[data-testid="picker-close-count"]');
+
   // TimeInput
   static getHourInput = async () => $('[data-testid="ds-controlled-date-time-picker-hour-input"]');
 

package/ds-form-date-range-picker/picker-callbacks/DateRangePicker.picker-callbacks.func.spec.js

@@ -0,0 +1,36 @@
+import { Key } from 'webdriverio';
+import DateRangePickerCO from '../DateRangePickerCO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  // Tests for the fix introduced in PUI-18907 (forward picker open and close callbacks).
+  describe('PUI-19082 - DSControlledDateRangePicker:: picker open and close callbacks - Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DateRangePickerCO.pickerCallbacks.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: should invoke onPickerOpen when the calendar opens', async () => {
+      const calendarTrigger = await DateRangePickerCO.getPickerBtn();
+      const openCallbackCount = await DateRangePickerCO.getOpenCallbackCount();
+
+      await expect(openCallbackCount).toHaveText('0');
+      await calendarTrigger.click();
+      await expect(await DateRangePickerCO.getCalendarDialog()).toBeDisplayedInViewport();
+      await expect(openCallbackCount).toHaveText('1');
+    });
+
+    it('02: should invoke onPickerClose when the calendar closes', async () => {
+      const closeCallbackCount = await DateRangePickerCO.getCloseCallbackCount();
+
+      await expect(closeCallbackCount).toHaveText('0');
+      await browser.keys(Key.Escape);
+      await expect(await DateRangePickerCO.getCalendarDialog()).not.toBeDisplayedInViewport();
+      await expect(closeCallbackCount).toHaveText('1');
+    });
+  });
+}

package/ds-global-header/GlobalHeaderCO.js

@@ -1,6 +1,6 @@
 /* eslint-disable import/no-relative-packages */
-import { PATH_E2E_GLOBAL_HEADER } from '../paths';
-import { PageObject, Urlbuilder, type } from '../helpers';
+import { PATH_E2E_GLOBAL_HEADER, PATH_E2E_GLOBAL_HEADER_PUI18647 } from '../paths';
+import { PageObject, Urlbuilder, getElementByIndex, type } from '../helpers';
 
 export default class GlobalHeader extends PageObject {
   static basicURL = new Urlbuilder(PATH_E2E_GLOBAL_HEADER, 'basic');
@@ -31,6 +31,19 @@ export default class GlobalHeader extends PageObject {
 
   static withLayoutProvider = new Urlbuilder(PATH_E2E_GLOBAL_HEADER, 'with-layout-provider');
 
+  // PUI-18647 — one story per out-of-the-box toolbar item type, each a minimal header carrying only
+  // that item with every injection point wired to data-public="true".
+  static appPickerPassthroughURL = new Urlbuilder(PATH_E2E_GLOBAL_HEADER_PUI18647, 'app-picker-contract-passthrough');
+
+  static iconButtonItemURL = new Urlbuilder(PATH_E2E_GLOBAL_HEADER_PUI18647, 'icon-button-item-attributes');
+
+  static popupMenuSlotSurfaceURL = new Urlbuilder(PATH_E2E_GLOBAL_HEADER_PUI18647, 'popup-menu-slot-surface');
+
+  static searchToggleSlotsURL = new Urlbuilder(
+    PATH_E2E_GLOBAL_HEADER_PUI18647,
+    'search-toggle-item-attributes-and-slots',
+  );
+
   // Selectors
   static async getGHBreadcrumbBtn(label) {
     return $(`//a[@data-testid="gh-breadcrumb-btn"]/span[contains(text(),"${label}")]/ancestor::a`);
@@ -108,6 +121,87 @@ export default class GlobalHeader extends PageObject {
     await spinButton.click();
   }
 
+  // PUI-18647 selectors
+
+  // Every element the stories wire to data-public="true". The assertions read this collection rather
+  // than probing one testid at a time: the contract under test is "the whole surface is reachable",
+  // so a slot silently dropping out has to fail the count, not slip through an unasserted gap.
+  static async getPublicNodes() {
+    return $$('[data-public="true"]');
+  }
+
+  static async getPublicNodeTestIds() {
+    const nodes = await GlobalHeader.getPublicNodes();
+    return Promise.all(Array.from({ length: nodes.length }, (_, index) => nodes[index].getAttribute('data-testid')));
+  }
+
+  // The stories render "Yes" here if any element in the page carries a type="ds-*" attribute. The
+  // toolbar `type` discriminator is internal routing and must never reach the DOM — `type` is a
+  // reserved HTML attribute.
+  static async getDsTypedItemExistFlag() {
+    return $('[data-testid="pui18647-ds-typed-item-exist"]');
+  }
+
+  static async getClickCount() {
+    return $('[data-testid="pui18647-click-count"]');
+  }
+
+  // A custom TriggerComponent handed to the app-picker item through componentProps. Its presence is
+  // what proves componentProps reaches DSAppPicker at all: it replaces the built-in trigger, so
+  // there is no `gh-toolbar-item` button in that story.
+  static async getAppPickerCustomTrigger() {
+    return $('[data-testid="pui18647-gh-apppicker-trigger-component"]');
+  }
+
+  // The popup-menu item's own root. Before PUI-18647 this element was an unstyled wrapper with no
+  // slot and no data-testid, so the item as a whole had no injection point.
+  static async getPopupMenuContainer() {
+    return $('[data-testid="ds-globalheader-menubar-item-popupmenu-container"]');
+  }
+
+  static async getPopupMenuItemButtons() {
+    return $$('[data-testid="ds-global-header-menubar-item-popupmenu-item-button"]');
+  }
+
+  static async getPopupMenuItemButtonByIndex(index = 0) {
+    return getElementByIndex(GlobalHeader.getPopupMenuItemButtons, index);
+  }
+
+  // The search-toggle item's root container. Item-level global attributes land HERE for this item
+  // type, not on the trigger button as with the sibling types.
+  static async getSearchToggleContainer() {
+    return $('[data-testid="ds-globalheader-menubar-item-searchtoggle-container"]');
+  }
+
+  static async getSearchTogglePrevButton() {
+    return $('[data-testid="ds-globalheader-searchtoggle-spinbutton-prev"]');
+  }
+
+  static async getSearchToggleNextButton() {
+    return $('[data-testid="ds-globalheader-searchtoggle-spinbutton-next"]');
+  }
+
+  // A neutral, non-focusable target outside any open overlay, used to assert that dismissing by
+  // pointer leaves focus where the click put it instead of yanking it back to the trigger.
+  // Anchored on a data-testid rather than on a tag: $('h1') matches Storybook's own hidden
+  // "No Preview" heading first, which is not clickable and is not part of the story at all.
+  static async getOutsideClickTarget() {
+    return GlobalHeader.getDsTypedItemExistFlag();
+  }
+
+  static async getSearchableRowByIndex(index = 0) {
+    return $(`[data-testid="pui18647-row-${index}"]`);
+  }
+
+  // The stories highlight the current result with an inline khaki background, so the selected row is
+  // read off the computed style rather than a semantic attribute — there is no semantic one to read.
+  // Matched on the rgb channels only: browsers disagree on whether to emit `rgb(...)` or `rgba(...,1)`
+  // and on internal spacing, and none of that is what the assertion is about.
+  static async isRowHighlighted(row) {
+    const { value } = await row.getCSSProperty('background-color');
+    return String(value).replace(/\s/g, '').includes('240,230,140');
+  }
+
   // Slots
 
   static async getGHBreadcrumbChevronlotByIndex(index = 0) {

package/ds-global-header/app-picker-passthrough/GlobalHeader.app-picker-passthrough.func.spec.js

@@ -0,0 +1,113 @@
+import { Key } from 'webdriverio';
+import GlobalHeaderCO from '../GlobalHeaderCO';
+import DSAppPickerCO from '../../ds-apppicker/DSAppPickerCO';
+
+// Tests for the fix in PUI-18647. Only a hand-maintained subset of props reached the out-of-the-box
+// GlobalHeader -> DSAppPicker item; the rest were silently dropped, so the item could not customise
+// the picker's slots at all. The reported symptom was `dsApppickerChip={{ 'data-public': true }}`
+// never arriving, leaving LogRocket masking the app icons and labels (blocks ENCW-136789).
+//
+// The hand-off is now a full contract passthrough, which this spec proves along three channels:
+//   1. the nine DSAppPicker slot props,
+//   2. non-slot members of the same contract — TriggerComponent, onOpen/onClose, id,
+//   3. GlobalHeader's own slots, which had to keep working across the refactor.
+//
+// Two a11y changes ride along and are pinned here because QA selectors depend on them: the trigger's
+// aria-haspopup is now "dialog" rather than "true", and it no longer carries aria-expanded (a dialog
+// announces its open state by being present). Open state is therefore asserted via the panel, never
+// via the attribute.
+//
+// Chrome only: DOM attributes plus programmatic focus landings, identical in every engine. The
+// `|| 'Chrome'` arm is mandatory (BrowserStack capitalises browserName; a lowercase-only guard
+// registers zero tests and still exits 0).
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-19015 - GlobalHeader:: app-picker componentProps contract passthrough - Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await GlobalHeaderCO.appPickerPassthroughURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: should render the custom trigger handed through componentProps', async () => {
+      const trigger = await GlobalHeaderCO.getAppPickerCustomTrigger();
+      await trigger.waitForDisplayed();
+      await expect(trigger).toHaveText('Apps');
+
+      // componentProps.id reaches DSAppPicker and namespaces the generated trigger id.
+      await expect(await trigger.getAttribute('id')).toBe('pui18647-gh-apppicker-dialog-trigger-btn');
+
+      await expect(trigger).toHaveAttribute('aria-haspopup', 'dialog');
+      // Absent by design — asserting the panel is present is the supported way to read open state.
+      await expect(await trigger.getAttribute('aria-expanded')).toBe(null);
+
+      const dsTypedFlag = await GlobalHeaderCO.getDsTypedItemExistFlag();
+      await expect(dsTypedFlag).toHaveText('No');
+    });
+
+    it("02: should keep forwarding GlobalHeader's own slots while the picker is closed", async () => {
+      const publicTestIds = await GlobalHeaderCO.getPublicNodeTestIds();
+      await expect(publicTestIds).toEqual([
+        'ds-global-header',
+        'ds-global-header-logo-container',
+        'ds-global-header-menubar-container',
+        'ds-global-header-menubar-list',
+        'ds-global-header-menubar-item',
+      ]);
+    });
+
+    it('03: should forward every app-picker slot prop and the onOpen callback', async () => {
+      await (await GlobalHeaderCO.getAppPickerCustomTrigger()).click();
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed();
+
+      // The story's onOpen re-scans the document, so the table only grows if that callback arrived
+      // too — the count below is simultaneously the slot assertion and the onOpen assertion.
+      const publicTestIds = await GlobalHeaderCO.getPublicNodeTestIds();
+      const countOf = (testId) => publicTestIds.filter((id) => id === testId).length;
+
+      // Three apps, two custom apps, one separator between the two sections.
+      await expect(countOf('ds-apppicker-root')).toBe(1);
+      await expect(countOf('ds-apppicker-group')).toBe(2);
+      await expect(countOf('ds-apppicker-row')).toBe(3);
+      await expect(countOf('ds-apppicker-title')).toBe(2);
+      await expect(countOf('ds-apppicker-item')).toBe(5);
+      await expect(countOf('ds-apppicker-separator')).toBe(1);
+      await expect(countOf('ds-apppicker-floating-wrapper')).toBe(1);
+      // dsApppickerChip — the prop the defect was raised about. One tagged node per app.
+      await expect(countOf('app-picker__chip')).toBe(5);
+
+      // The panel is a dialog named by the custom trigger, so the widened contract did not cost the
+      // picker its ARIA pattern.
+      const dialog = await DSAppPickerCO.getFloatingWrapper();
+      await expect(dialog).toHaveAttribute('role', 'dialog');
+      await expect(await dialog.getAttribute('aria-labelledby')).toBe(
+        await (await GlobalHeaderCO.getAppPickerCustomTrigger()).getAttribute('id'),
+      );
+
+      const dsTypedFlag = await GlobalHeaderCO.getDsTypedItemExistFlag();
+      await expect(dsTypedFlag).toHaveText('No');
+    });
+
+    it('04: should open onto the selected app with ArrowDown and ArrowUp', async () => {
+      // The toolbar is a menubar, so it opts the picker into openAndFocusOnArrowKeys. 'Reports' is
+      // the third app, so "landed on the selected app" cannot be read as "landed on the first app".
+      await browser.keys(Key.Escape);
+      const trigger = await GlobalHeaderCO.getAppPickerCustomTrigger();
+      await expect(trigger).toBeFocused();
+
+      await browser.keys(Key.ArrowDown);
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed();
+      await expect(await DSAppPickerCO.getChipByLabel('Reports')).toBeFocused();
+
+      // ArrowUp opens nothing before this change; it now lands on the same selected app.
+      await browser.keys(Key.Escape);
+      await expect(trigger).toBeFocused();
+      await browser.keys(Key.ArrowUp);
+      await (await DSAppPickerCO.getAppPickerRoot()).waitForDisplayed();
+      await expect(await DSAppPickerCO.getChipByLabel('Reports')).toBeFocused();
+    });
+  });
+}