From 74c2f7c0d255bfa6eb7e54ec6480bcf5afaf5b72 Mon Sep 17 00:00:00 2001
From: Maria Hutt <thetaPC@users.noreply.github.com>
Date: Wed, 2 Sep 2026 15:48:54 -0700
Subject: [PATCH 1/2] fix(input, select, textarea): emit one click event when
 slotted content is clicked

---
 core/src/components/input/input.tsx           |  18 +--
 .../components/input/test/basic/input.e2e.ts  |  67 +++++++++++
 core/src/components/select/select.tsx         | 112 ++++++++++++------
 .../select/test/basic/select.e2e.ts           |  91 ++++++++++++++
 .../textarea/test/basic/textarea.e2e.ts       |  67 +++++++++++
 core/src/components/textarea/textarea.tsx     |  18 +--
 core/src/utils/forms/index.ts                 |   1 +
 core/src/utils/forms/slotted-click.ts         |  66 +++++++++++
 8 files changed, 392 insertions(+), 48 deletions(-)
 create mode 100644 core/src/utils/forms/slotted-click.ts

diff --git a/core/src/components/input/input.tsx b/core/src/components/input/input.tsx
index dbbff605692..32bcd092ead 100644
--- a/core/src/components/input/input.tsx
+++ b/core/src/components/input/input.tsx
@@ -13,8 +13,13 @@ import {
   forceUpdate,
   h,
 } from '@stencil/core';
-import type { NotchController, StartContainerController } from '@utils/forms';
-import { createNotchController, createStartContainerController, checkInvalidState } from '@utils/forms';
+import type { NotchController, SlottedClickController, StartContainerController } from '@utils/forms';
+import {
+  createNotchController,
+  createSlottedClickController,
+  createStartContainerController,
+  checkInvalidState,
+} from '@utils/forms';
 import type { Attributes } from '@utils/helpers';
 import { inheritAriaAttributes, debounceEvent, inheritAttributes, componentOnReady } from '@utils/helpers';
 import { createSlotMutationController } from '@utils/slot-mutation-controller';
@@ -56,6 +61,7 @@ export class Input implements ComponentInterface {
   private notchSpacerEl: HTMLElement | undefined;
   private startContainerController?: StartContainerController;
   private startContainerEl: HTMLElement | undefined;
+  private slottedClickController?: SlottedClickController;
 
   private originalIonInput?: EventEmitter<InputInputEventDetail>;
 
@@ -392,11 +398,7 @@ export class Input implements ComponentInterface {
    */
   @Listen('click', { capture: true })
   onClickCapture(ev: Event) {
-    const nativeInput = this.nativeInput;
-    if (nativeInput && ev.target === nativeInput) {
-      ev.stopPropagation();
-      this.el.click();
-    }
+    this.slottedClickController?.handleClickCapture(ev);
   }
 
   componentWillLoad() {
@@ -433,6 +435,8 @@ export class Input implements ComponentInterface {
 
     this.startContainerController.calculateStartContainerWidth();
 
+    this.slottedClickController = createSlottedClickController(el, () => this.nativeInput);
+
     // Watch for class changes to update validation state
     if (Build.isBrowser && typeof MutationObserver !== 'undefined') {
       this.validationObserver = new MutationObserver(() => {
diff --git a/core/src/components/input/test/basic/input.e2e.ts b/core/src/components/input/test/basic/input.e2e.ts
index 65a921a0f6f..4ae15f12528 100644
--- a/core/src/components/input/test/basic/input.e2e.ts
+++ b/core/src/components/input/test/basic/input.e2e.ts
@@ -347,3 +347,70 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
     });
   });
 });
+
+/**
+ * Slotted click behavior does not vary by mode or direction.
+ */
+configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
+  test.describe(title('input: slotted click'), () => {
+    test.beforeEach(async ({ page }) => {
+      await page.setContent(
+        `
+        <ion-input label="Email">
+          <ion-icon id="start-icon" slot="start" name="lock-closed" aria-hidden="true"></ion-icon>
+          <ion-button id="end-button" slot="end" aria-label="Show password">
+            <ion-icon slot="icon-only" name="eye" aria-hidden="true"></ion-icon>
+          </ion-button>
+        </ion-input>
+      `,
+        config
+      );
+    });
+
+    test('should emit one click when a slotted icon is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#start-icon').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+
+      const event = clickEvent.events[0];
+      expect((event.target as HTMLElement).tagName.toLowerCase()).toBe('ion-icon');
+    });
+
+    test('should focus the input when a slotted icon is clicked', async ({ page }) => {
+      await page.locator('#start-icon').click();
+
+      await expect(page.locator('ion-input input')).toBeFocused();
+    });
+
+    test('should emit one click when a slotted button is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#end-button').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+    });
+
+    test('should not focus the input when a slotted button is clicked', async ({ page }) => {
+      await page.locator('#end-button').click();
+
+      await expect(page.locator('ion-input input')).not.toBeFocused();
+    });
+
+    test('should emit one click when the input is clicked after slotted content', async ({ page }) => {
+      /**
+       * Clicking a slotted button does not produce a forwarded click for the
+       * input to ignore, so the following click on the input itself must
+       * still be emitted.
+       */
+      await page.locator('#end-button').click();
+
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('ion-input input').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+    });
+  });
+});
diff --git a/core/src/components/select/select.tsx b/core/src/components/select/select.tsx
index 7c3f7f7477f..dc06a02bd5d 100644
--- a/core/src/components/select/select.tsx
+++ b/core/src/components/select/select.tsx
@@ -1,6 +1,20 @@
 import type { ComponentInterface, EventEmitter } from '@stencil/core';
-import { Build, Component, Element, Event, Host, Method, Prop, State, Watch, h, forceUpdate } from '@stencil/core';
+import {
+  Build,
+  Component,
+  Element,
+  Event,
+  Host,
+  Listen,
+  Method,
+  Prop,
+  State,
+  Watch,
+  h,
+  forceUpdate,
+} from '@stencil/core';
 import { ENABLE_HTML_CONTENT_DEFAULT } from '@utils/config';
+import { focusableQueryString } from '@utils/focus-trap';
 import type { NotchController, StartContainerController } from '@utils/forms';
 import {
   compareOptions,
@@ -8,8 +22,9 @@ import {
   createStartContainerController,
   isOptionSelected,
   checkInvalidState,
+  isSlottedClick,
 } from '@utils/forms';
-import { focusVisibleElement, renderHiddenInput, inheritAttributes } from '@utils/helpers';
+import { focusVisibleElement, renderHiddenInput, inheritAttributes, raf } from '@utils/helpers';
 import type { Attributes } from '@utils/helpers';
 import { printIonWarning } from '@utils/logging';
 import { actionSheetController, alertController, popoverController, modalController } from '@utils/overlays';
@@ -91,6 +106,14 @@ export class Select implements ComponentInterface {
   private startContainerEl: HTMLElement | undefined;
   private customHTMLEnabled = config.get('innerHTMLTemplatesEnabled', ENABLE_HTML_CONTENT_DEFAULT);
 
+  /**
+   * `true` if the click currently being dispatched started on content slotted
+   * into the select. Used to ignore the click the wrapping label forwards to
+   * the internal button so that a single click is not emitted twice and does
+   * not open the select.
+   */
+  private hasSlottedClick = false;
+
   @Element() el!: HTMLIonSelectElement;
 
   @State() isExpanded = false;
@@ -993,42 +1016,54 @@ export class Select implements ComponentInterface {
     this.ionStyle.emit(style);
   }
 
-  private onClick = (ev: UIEvent) => {
-    const target = ev.target as HTMLElement;
-    const closestSlot = target.closest('[slot="start"], [slot="end"]');
+  /**
+   * Clicking slotted content also clicks the <label> that wraps the slots.
+   * The label has no `for` attribute, so the browser forwards the click to its
+   * first labelable descendant, the internal button. That forwarded click
+   * bubbles back out of the shadow root targeting the host, which would emit a
+   * second click event and open the select.
+   *
+   * The forwarded click is swallowed here, during the capture phase, so it
+   * never reaches listeners on the host. The click on the slotted content
+   * itself is left alone so that slotted links, checkboxes and buttons keep
+   * their default behavior, and so click handlers on slotted content still
+   * fire in React. React attaches a native "click" listener on the root
+   * element and dispatches its synthetic event from there, so calling
+   * stopPropagation() on the slotted click would stop those handlers running.
+   */
+  @Listen('click', { capture: true })
+  onClickCapture(ev: Event) {
+    if (isSlottedClick(ev, this.el)) {
+      this.hasSlottedClick = true;
 
-    if (target === this.el || closestSlot === null) {
-      this.setFocus();
-      this.open(ev);
-    } else {
       /**
-       * Prevent clicks to the start/end slots from opening the select.
-       * We ensure the target isn't this element in case the select is slotted
-       * in, for example, an item. This would prevent the select from ever
-       * being opened since the element itself has slot="start"/"end".
-       *
-       * Clicking a slotted element also causes a click
-       * on the <label> element (since it wraps the slots).
-       * Clicking <label> dispatches another click event on
-       * the native form control that then bubbles up to this
-       * listener. This additional event targets the host
-       * element, so the select overlay is opened.
-       *
-       * When the slotted elements are clicked (and therefore
-       * the ancestor <label> element) we want to prevent the label
-       * from dispatching another click event.
-       *
-       * Do not call stopPropagation() because this will cause
-       * click handlers on the slotted elements to never fire in React.
-       * When developers do onClick in React a native "click" listener
-       * is added on the root element, not the slotted element. When that
-       * native click listener fires, React then dispatches the synthetic
-       * click event on the slotted element. However, if stopPropagation
-       * is called then the native click event will never bubble up
-       * to the root element.
+       * Browsers skip the label forwarding when the click lands on interactive
+       * content, such as a slotted button, so the flag is cleared on the next
+       * frame rather than waiting for a forwarded click that never arrives.
        */
-      ev.preventDefault();
+      raf(() => (this.hasSlottedClick = false));
+      return;
     }
+
+    if (this.hasSlottedClick) {
+      ev.stopPropagation();
+      this.hasSlottedClick = false;
+    }
+  }
+
+  private onClick = (ev: UIEvent) => {
+    /**
+     * Interactive slotted content, such as a button or a link, handles its own
+     * click, so it should not open the select as well. Any other slotted
+     * content is decorative and behaves the same as clicking the select itself.
+     */
+    const deepTarget = ev.composedPath()[0] as HTMLElement;
+    if (isSlottedClick(ev, this.el) && deepTarget.closest(INTERACTIVE_SLOTTED_CONTENT) !== null) {
+      return;
+    }
+
+    this.setFocus();
+    this.open(ev);
   };
 
   private onFocus = () => {
@@ -1692,3 +1727,12 @@ const extractOptionContent = (option: HTMLIonSelectOptionElement, customHTMLEnab
 let selectIds = 0;
 
 const OPTION_CLASS = 'select-interface-option';
+
+/**
+ * Slotted content that the browser focuses or activates on its own when it is
+ * clicked. A <label> skips forwarding a click to its control when the click
+ * lands on content like this, so the select leaves it alone as well.
+ * Anchors are included because they are interactive without being focusable
+ * by the definition `focusableQueryString` uses.
+ */
+const INTERACTIVE_SLOTTED_CONTENT = `${focusableQueryString}, a[href]`;
diff --git a/core/src/components/select/test/basic/select.e2e.ts b/core/src/components/select/test/basic/select.e2e.ts
index 2e2582abe3c..7fa4cf30a5f 100644
--- a/core/src/components/select/test/basic/select.e2e.ts
+++ b/core/src/components/select/test/basic/select.e2e.ts
@@ -1339,3 +1339,94 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
     });
   });
 });
+
+/**
+ * Slotted click behavior does not vary by mode or direction.
+ */
+configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
+  test.describe(title('select: slotted click'), () => {
+    test.beforeEach(async ({ page }) => {
+      await page.setContent(
+        `
+        <ion-select label="Fruit" interface="alert">
+          <ion-icon id="start-icon" slot="start" name="pizza" aria-hidden="true"></ion-icon>
+          <ion-button id="end-button" slot="end" aria-label="Clear selection">
+            <ion-icon slot="icon-only" name="trash" aria-hidden="true"></ion-icon>
+          </ion-button>
+          <input id="end-checkbox" slot="end" type="checkbox" aria-label="Favorite" />
+          <ion-select-option value="apple">Apple</ion-select-option>
+        </ion-select>
+      `,
+        config
+      );
+    });
+
+    test('should emit one click when a slotted icon is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#start-icon').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+
+      const event = clickEvent.events[0];
+      expect((event.target as HTMLElement).tagName.toLowerCase()).toBe('ion-icon');
+    });
+
+    /**
+     * Decorative slotted content behaves the same as clicking the select
+     * itself, so it opens the overlay.
+     */
+    test('should open when a slotted icon is clicked', async ({ page }) => {
+      const ionAlertDidPresent = await page.spyOnEvent('ionAlertDidPresent');
+
+      await page.locator('#start-icon').click();
+      await ionAlertDidPresent.next();
+
+      await expect(page.locator('ion-alert')).toBeVisible();
+    });
+
+    test('should emit one click when a slotted button is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#end-button').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+    });
+
+    test('should not open when a slotted button is clicked', async ({ page }) => {
+      await page.locator('#end-button').click();
+
+      await expect(page.locator('ion-alert')).toHaveCount(0);
+    });
+
+    test('should not focus the select when a slotted button is clicked', async ({ page }) => {
+      await page.locator('#end-button').click();
+
+      await expect(page.locator('ion-select')).not.toHaveClass(/has-focus/);
+    });
+
+    test('should activate slotted form controls', async ({ page }) => {
+      const checkbox = page.locator('#end-checkbox');
+
+      await checkbox.click();
+
+      await expect(checkbox).toBeChecked();
+    });
+
+    test('should open when the select is clicked after slotted content', async ({ page }) => {
+      /**
+       * Clicking a slotted button does not produce a forwarded click for the
+       * select to ignore, so the following click on the select itself must
+       * still open it.
+       */
+      await page.locator('#end-button').click();
+
+      const ionAlertDidPresent = await page.spyOnEvent('ionAlertDidPresent');
+
+      await page.locator('ion-select').click({ position: { x: 5, y: 5 } });
+      await ionAlertDidPresent.next();
+
+      await expect(page.locator('ion-alert')).toBeVisible();
+    });
+  });
+});
diff --git a/core/src/components/textarea/test/basic/textarea.e2e.ts b/core/src/components/textarea/test/basic/textarea.e2e.ts
index 75db2a90550..647ab791c84 100644
--- a/core/src/components/textarea/test/basic/textarea.e2e.ts
+++ b/core/src/components/textarea/test/basic/textarea.e2e.ts
@@ -249,3 +249,70 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
     });
   });
 });
+
+/**
+ * Slotted click behavior does not vary by mode or direction.
+ */
+configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
+  test.describe(title('textarea: slotted click'), () => {
+    test.beforeEach(async ({ page }) => {
+      await page.setContent(
+        `
+        <ion-textarea label="Notes">
+          <ion-icon id="start-icon" slot="start" name="lock-closed" aria-hidden="true"></ion-icon>
+          <ion-button id="end-button" slot="end" aria-label="Clear notes">
+            <ion-icon slot="icon-only" name="trash" aria-hidden="true"></ion-icon>
+          </ion-button>
+        </ion-textarea>
+      `,
+        config
+      );
+    });
+
+    test('should emit one click when a slotted icon is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#start-icon').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+
+      const event = clickEvent.events[0];
+      expect((event.target as HTMLElement).tagName.toLowerCase()).toBe('ion-icon');
+    });
+
+    test('should focus the textarea when a slotted icon is clicked', async ({ page }) => {
+      await page.locator('#start-icon').click();
+
+      await expect(page.locator('ion-textarea textarea')).toBeFocused();
+    });
+
+    test('should emit one click when a slotted button is clicked', async ({ page }) => {
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('#end-button').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+    });
+
+    test('should not focus the textarea when a slotted button is clicked', async ({ page }) => {
+      await page.locator('#end-button').click();
+
+      await expect(page.locator('ion-textarea textarea')).not.toBeFocused();
+    });
+
+    test('should emit one click when the textarea is clicked after slotted content', async ({ page }) => {
+      /**
+       * Clicking a slotted button does not produce a forwarded click for the
+       * textarea to ignore, so the following click on the textarea itself
+       * must still be emitted.
+       */
+      await page.locator('#end-button').click();
+
+      const clickEvent = await page.spyOnEvent('click');
+
+      await page.locator('ion-textarea textarea').click();
+
+      expect(clickEvent).toHaveReceivedEventTimes(1);
+    });
+  });
+});
diff --git a/core/src/components/textarea/textarea.tsx b/core/src/components/textarea/textarea.tsx
index 5fd398bb9d3..bdb8826623b 100644
--- a/core/src/components/textarea/textarea.tsx
+++ b/core/src/components/textarea/textarea.tsx
@@ -14,8 +14,13 @@ import {
   h,
   writeTask,
 } from '@stencil/core';
-import type { NotchController, StartContainerController } from '@utils/forms';
-import { createNotchController, createStartContainerController, checkInvalidState } from '@utils/forms';
+import type { NotchController, SlottedClickController, StartContainerController } from '@utils/forms';
+import {
+  createNotchController,
+  createSlottedClickController,
+  createStartContainerController,
+  checkInvalidState,
+} from '@utils/forms';
 import type { Attributes } from '@utils/helpers';
 import { inheritAriaAttributes, debounceEvent, inheritAttributes, componentOnReady } from '@utils/helpers';
 import { createSlotMutationController } from '@utils/slot-mutation-controller';
@@ -65,6 +70,7 @@ export class Textarea implements ComponentInterface {
   private notchSpacerEl: HTMLElement | undefined;
   private startContainerController?: StartContainerController;
   private startContainerEl: HTMLElement | undefined;
+  private slottedClickController?: SlottedClickController;
 
   /**
    * The value of the textarea when the textarea is focused.
@@ -330,11 +336,7 @@ export class Textarea implements ComponentInterface {
    */
   @Listen('click', { capture: true })
   onClickCapture(ev: Event) {
-    const nativeInput = this.nativeInput;
-    if (nativeInput && ev.target === nativeInput) {
-      ev.stopPropagation();
-      this.el.click();
-    }
+    this.slottedClickController?.handleClickCapture(ev);
   }
 
   connectedCallback() {
@@ -362,6 +364,8 @@ export class Textarea implements ComponentInterface {
 
     this.startContainerController.calculateStartContainerWidth();
 
+    this.slottedClickController = createSlottedClickController(el, () => this.nativeInput);
+
     // Watch for class changes to update validation state
     if (Build.isBrowser && typeof MutationObserver !== 'undefined') {
       this.validationObserver = new MutationObserver(() => {
diff --git a/core/src/utils/forms/index.ts b/core/src/utils/forms/index.ts
index 1d31ca31bc5..ba0322eea82 100644
--- a/core/src/utils/forms/index.ts
+++ b/core/src/utils/forms/index.ts
@@ -2,4 +2,5 @@ export * from './notch-controller';
 export * from './start-container-controller';
 export * from './compare-with-utils';
 export * from './item-multiple-inputs';
+export * from './slotted-click';
 export * from './validity';
diff --git a/core/src/utils/forms/slotted-click.ts b/core/src/utils/forms/slotted-click.ts
new file mode 100644
index 00000000000..3f4d38ec420
--- /dev/null
+++ b/core/src/utils/forms/slotted-click.ts
@@ -0,0 +1,66 @@
+import { raf } from '@utils/helpers';
+
+export interface SlottedClickController {
+  handleClickCapture: (ev: Event) => void;
+}
+
+/**
+ * Whether a click started on content slotted into a form control's start or
+ * end slot.
+ *
+ * The slotted element is compared against the host in case the form control
+ * itself is slotted into, for example, an item. Without that check a control
+ * carrying slot="start"/"end" would treat every click on itself as a slotted
+ * click.
+ */
+export const isSlottedClick = (ev: Event, el: HTMLElement): boolean => {
+  const slotted = (ev.target as HTMLElement).closest('[slot="start"], [slot="end"]');
+
+  return slotted !== null && slotted !== el && el.contains(slotted);
+};
+
+/**
+ * A utility for form components that wrap their content in a <label> pointing
+ * at a native control, such as ion-input and ion-textarea.
+ *
+ * Those components emit the click event from the host rather than the native
+ * control, which means re-dispatching the click when the native control is
+ * the target. Clicking slotted content has already reached listeners on the
+ * host by the time the label forwards a click to the native control, so the
+ * forwarded click has to be left alone or a single click is emitted twice.
+ *
+ * Browsers skip that forwarding when the click lands on interactive content,
+ * such as a slotted button, so the slotted click is remembered for a frame
+ * rather than until a forwarded click that may never arrive.
+ *
+ * @internal
+ * @param el - The host element (ion-input or ion-textarea).
+ * @param getNativeInput - A callback that returns the native form control.
+ */
+export const createSlottedClickController = (
+  el: HTMLElement,
+  getNativeInput: () => HTMLInputElement | HTMLTextAreaElement | undefined
+): SlottedClickController => {
+  let hasSlottedClick = false;
+
+  const handleClickCapture = (ev: Event) => {
+    if (isSlottedClick(ev, el)) {
+      hasSlottedClick = true;
+      raf(() => (hasSlottedClick = false));
+      return;
+    }
+
+    const nativeInput = getNativeInput();
+    if (nativeInput !== undefined && ev.target === nativeInput) {
+      ev.stopPropagation();
+
+      if (!hasSlottedClick) {
+        el.click();
+      }
+
+      hasSlottedClick = false;
+    }
+  };
+
+  return { handleClickCapture };
+};

From 50c3244aac1d7238c1414938a53dccbb4618ceb7 Mon Sep 17 00:00:00 2001
From: Maria Hutt <thetaPC@users.noreply.github.com>
Date: Wed, 2 Sep 2026 19:22:54 -0700
Subject: [PATCH 2/2] test(input, select, textarea): update comment

---
 core/src/components/input/test/basic/input.e2e.ts       | 2 +-
 core/src/components/select/test/basic/select.e2e.ts     | 2 +-
 core/src/components/textarea/test/basic/textarea.e2e.ts | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/components/input/test/basic/input.e2e.ts b/core/src/components/input/test/basic/input.e2e.ts
index 4ae15f12528..de74aaacfc2 100644
--- a/core/src/components/input/test/basic/input.e2e.ts
+++ b/core/src/components/input/test/basic/input.e2e.ts
@@ -349,7 +349,7 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
 });
 
 /**
- * Slotted click behavior does not vary by mode or direction.
+ * This behavior does not vary across directions/modes
  */
 configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
   test.describe(title('input: slotted click'), () => {
diff --git a/core/src/components/select/test/basic/select.e2e.ts b/core/src/components/select/test/basic/select.e2e.ts
index 7fa4cf30a5f..7966c8ab46c 100644
--- a/core/src/components/select/test/basic/select.e2e.ts
+++ b/core/src/components/select/test/basic/select.e2e.ts
@@ -1341,7 +1341,7 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
 });
 
 /**
- * Slotted click behavior does not vary by mode or direction.
+ * This behavior does not vary across directions/modes
  */
 configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
   test.describe(title('select: slotted click'), () => {
diff --git a/core/src/components/textarea/test/basic/textarea.e2e.ts b/core/src/components/textarea/test/basic/textarea.e2e.ts
index 647ab791c84..221bb2b000a 100644
--- a/core/src/components/textarea/test/basic/textarea.e2e.ts
+++ b/core/src/components/textarea/test/basic/textarea.e2e.ts
@@ -251,7 +251,7 @@ configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
 });
 
 /**
- * Slotted click behavior does not vary by mode or direction.
+ * This behavior does not vary across directions/modes
  */
 configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
   test.describe(title('textarea: slotted click'), () => {