diff --git a/packages/react-aria-components/docs/ComboBox.mdx b/packages/react-aria-components/docs/ComboBox.mdx
index 30b302628f1..5ebe5f63311 100644
--- a/packages/react-aria-components/docs/ComboBox.mdx
+++ b/packages/react-aria-components/docs/ComboBox.mdx
@@ -512,6 +512,48 @@ any value within the field.
 </MyComboBox>
 ```
 
+### Custom values with multiple selection
+
+When `allowsCustomValue` is combined with `selectionMode="multiple"`, users can both select predefined items and type custom values. Pressing Enter or Tab with a non-matching input adds the typed text as a custom value to the selection. The input clears after each selection so the user can continue searching. Pressing Escape discards the typed text without affecting the current selection.
+
+Custom values appear in `selectedItems` as nodes with `value: null` and `textValue` set to the custom string. You can distinguish them from collection items by checking `item.value`.
+
+```tsx example
+import {ComboBoxStateContext, TagGroup, TagList, Tag} from 'react-aria-components';
+
+<ComboBox allowsEmptyCollection allowsCustomValue selectionMode="multiple">
+  <Label>Favorite Animals</Label>
+  <div className="my-combobox-container">
+    <Input />
+    <Button><ChevronDown size={16} /></Button>
+  </div>
+  <ComboBoxStateContext.Consumer>
+    {state => state && (
+      <TagGroup
+        aria-label="Selected items"
+        onRemove={(keys) => {
+          if (Array.isArray(state.value)) {
+            state.setValue(state.value.filter(k => !keys.has(k)));
+          }
+        }}>
+        <TagList items={state.selectedItems.map(item => item.value ?? {id: item.key, name: item.textValue})}>
+          {item => <Tag>{item.name}</Tag>}
+        </TagList>
+      </TagGroup>
+    )}
+  </ComboBoxStateContext.Consumer>
+  <Popover>
+    <ListBox renderEmptyState={() => <div className="my-item">No results found</div>}>
+      <ListBoxItem id="red panda">Red Panda</ListBoxItem>
+      <ListBoxItem id="cat">Cat</ListBoxItem>
+      <ListBoxItem id="dog">Dog</ListBoxItem>
+      <ListBoxItem id="kangaroo">Kangaroo</ListBoxItem>
+      <ListBoxItem id="snake">Snake</ListBoxItem>
+    </ListBox>
+  </Popover>
+</ComboBox>
+```
+
 ### HTML forms
 
 ComboBox supports the `name` prop for integration with HTML forms. By default, the `id` of the selected item will be submitted to the server. If the `formValue` prop is set to `"text"` or the `allowsCustomValue` prop is true, the text in the input field will be submitted instead.
diff --git a/packages/react-aria-components/src/ComboBox.tsx b/packages/react-aria-components/src/ComboBox.tsx
index d6ef3c99a87..d59b9fb3f4e 100644
--- a/packages/react-aria-components/src/ComboBox.tsx
+++ b/packages/react-aria-components/src/ComboBox.tsx
@@ -140,7 +140,7 @@ function ComboBoxInner<T extends object>({props, collection, comboBoxRef: ref}:
     formValue = 'key',
     allowsCustomValue
   } = props;
-  if (allowsCustomValue) {
+  if (allowsCustomValue && props.selectionMode !== 'multiple') {
     formValue = 'text';
   }
 
diff --git a/packages/react-aria-components/stories/ComboBox.stories.tsx b/packages/react-aria-components/stories/ComboBox.stories.tsx
index 95e5c268950..0a5f7847d52 100644
--- a/packages/react-aria-components/stories/ComboBox.stories.tsx
+++ b/packages/react-aria-components/stories/ComboBox.stories.tsx
@@ -20,6 +20,7 @@ import {ListBox} from '../src/ListBox';
 import {ListBoxLoadMoreItem} from '../src/ListBox';
 import {ListLayout} from 'react-stately/useVirtualizerState';
 import {LoadingSpinner, MyListBoxItem} from './utils';
+import {Key} from '@react-types/shared';
 import {Meta, StoryFn, StoryObj} from '@storybook/react';
 import {Popover} from '../src/Popover';
 import React, {JSX, useMemo, useState} from 'react';
@@ -437,6 +438,159 @@ export const MultiSelectComboBox: ComboBoxStory = () => (
   </ComboBox>
 );
 
+export const MultiSelectComboBoxAllowsCustomValue: ComboBoxStory = () => (
+  <ComboBox allowsEmptyCollection allowsCustomValue selectionMode="multiple" defaultItems={usStateOptions}>
+    <Label style={{display: 'block'}}>Test</Label>
+    <div style={{display: 'flex'}}>
+      <Input placeholder="Select or type a custom value" />
+      <Button>
+        <span aria-hidden="true" style={{padding: '0 2px'}}>▼</span>
+      </Button>
+    </div>
+    <ComboBoxStateContext.Consumer>
+      {state => state && (
+        <TagGroup
+          aria-label="Selected states"
+          items={state.selectedItems.map(item => item.value ?? {id: item.key, name: item.textValue})}
+          renderEmptyState={() => 'No selected items'}
+          onRemove={(keys) => {
+            if (Array.isArray(state.value)) {
+              state.setValue(state.value.filter(k => !keys.has(k)));
+            }
+          }}>
+          {item => <Tag>{item.name}</Tag>}
+        </TagGroup>
+      )}
+    </ComboBoxStateContext.Consumer>
+    <Popover placement="bottom end">
+      <ListBox<{name: string}>
+        renderEmptyState={renderEmptyState}
+        data-testid="combo-box-list-box"
+        className={styles.menu}>
+        {item => <MyListBoxItem>{item.name}</MyListBoxItem>}
+      </ListBox>
+    </Popover>
+  </ComboBox>
+);
+
+export function MultiSelectComboBoxAllowsCustomValueControlled() {
+  let [selectedKeys, setSelectedKeys] = useState<Key[]>([]);
+  let [inputValue, setInputValue] = useState('');
+  let {contains} = useFilter({sensitivity: 'base'});
+  let filteredItems = useMemo(() => usStateOptions.filter(item => contains(item.name, inputValue)), [inputValue, contains]);
+
+  return (
+    <div>
+      <div style={{marginBottom: 12, fontSize: 12, fontFamily: 'monospace'}}>
+        <div>inputValue: {JSON.stringify(inputValue)}</div>
+        <div>selectedKeys: {JSON.stringify(selectedKeys)}</div>
+      </div>
+      <ComboBox
+        allowsEmptyCollection
+        allowsCustomValue
+        selectionMode="multiple"
+        items={filteredItems}
+        value={selectedKeys}
+        onChange={setSelectedKeys}
+        inputValue={inputValue}
+        onInputChange={setInputValue}>
+        <Label style={{display: 'block'}}>Test</Label>
+        <div style={{display: 'flex'}}>
+          <Input placeholder="Select or type a custom value" />
+          <Button>
+            <span aria-hidden="true" style={{padding: '0 2px'}}>▼</span>
+          </Button>
+        </div>
+        <ComboBoxStateContext.Consumer>
+          {state => state && (
+            <TagGroup
+              aria-label="Selected states"
+              items={state.selectedItems.map(item => item.value ?? {id: item.key, name: item.textValue})}
+              renderEmptyState={() => 'No selected items'}
+              onRemove={(keys) => {
+                setSelectedKeys(prev => prev.filter(k => !keys.has(k)));
+              }}>
+              {item => <Tag>{item.name}</Tag>}
+            </TagGroup>
+          )}
+        </ComboBoxStateContext.Consumer>
+        <Popover placement="bottom end">
+          <ListBox<{id: string, name: string}>
+            renderEmptyState={renderEmptyState}
+            className={styles.menu}>
+            {item => <MyListBoxItem>{item.name}</MyListBoxItem>}
+          </ListBox>
+        </Popover>
+      </ComboBox>
+    </div>
+  );
+}
+
+export function MultiSelectComboBoxAllowsCustomValueForm() {
+  let [submittedData, setSubmittedData] = useState<string | null>(null);
+
+  return (
+    <div>
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+          let formData = new FormData(e.currentTarget);
+          let entries: Record<string, FormDataEntryValue[]> = {};
+          for (let [key, value] of formData.entries()) {
+            if (!entries[key]) {
+              entries[key] = [];
+            }
+            entries[key].push(value);
+          }
+          setSubmittedData(JSON.stringify(entries, null, 2));
+        }}>
+        <ComboBox
+          name="states"
+          allowsEmptyCollection
+          allowsCustomValue
+          selectionMode="multiple"
+          defaultItems={usStateOptions}>
+          <Label style={{display: 'block'}}>States</Label>
+          <div style={{display: 'flex'}}>
+            <Input placeholder="Select or type a custom value" />
+            <Button>
+              <span aria-hidden="true" style={{padding: '0 2px'}}>▼</span>
+            </Button>
+          </div>
+          <ComboBoxStateContext.Consumer>
+            {state => state && (
+              <TagGroup
+                aria-label="Selected states"
+                items={state.selectedItems.map(item => item.value ?? {id: item.key, name: item.textValue})}
+                renderEmptyState={() => 'No selected items'}
+                onRemove={(keys) => {
+                  if (Array.isArray(state.value)) {
+                    state.setValue(state.value.filter(k => !keys.has(k)));
+                  }
+                }}>
+                {item => <Tag>{item.name}</Tag>}
+              </TagGroup>
+            )}
+          </ComboBoxStateContext.Consumer>
+          <Popover placement="bottom end">
+            <ListBox<{name: string}>
+              renderEmptyState={renderEmptyState}
+              className={styles.menu}>
+              {item => <MyListBoxItem>{item.name}</MyListBoxItem>}
+            </ListBox>
+          </Popover>
+        </ComboBox>
+        <button type="submit" style={{marginTop: 8}}>Submit</button>
+      </form>
+      {submittedData && (
+        <pre style={{marginTop: 12, fontSize: 12, fontFamily: 'monospace', background: '#f5f5f5', padding: 8, color: '#000'}}>
+          {submittedData}
+        </pre>
+      )}
+    </div>
+  );
+}
+
 const usStateOptions = [
   {id: 'AL', name: 'Alabama'},
   {id: 'AK', name: 'Alaska'},
diff --git a/packages/react-aria-components/test/ComboBox.test.js b/packages/react-aria-components/test/ComboBox.test.js
index af75cba5644..583d8c2d356 100644
--- a/packages/react-aria-components/test/ComboBox.test.js
+++ b/packages/react-aria-components/test/ComboBox.test.js
@@ -786,16 +786,211 @@ describe('ComboBox', () => {
   });
 
   it('should support multi-select with custom value', async () => {
-    // allowsCustomValue doesn't really make sense to use with multi-selection, but test it anyway.
-    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue />);
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
     let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
 
     await user.tab();
     await user.keyboard('Test');
     expect(comboboxTester.combobox).toHaveValue('Test');
 
+    // Custom value should be committed to selection and input cleared
     await user.tab();
-    expect(comboboxTester.combobox).toHaveValue('Test');
+    expect(comboboxTester.combobox).toHaveValue('');
+    expect(onChange).toHaveBeenCalledWith(['Test']);
+  });
+
+  it('should not clear selection when pressing Escape with multi-select and allowsCustomValue', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox defaultValue={['1', '2']} selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('den');
+    expect(comboboxTester.combobox).toHaveValue('den');
+
+    await user.keyboard('{Escape}');
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('should not clear selection when pressing Tab with multi-select and allowsCustomValue and existing selection', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox defaultValue={['1', '2']} selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('den');
+    expect(comboboxTester.combobox).toHaveValue('den');
+
+    await user.tab();
+    // "den" doesn't match any item, so it's added as a custom value
+    expect(onChange).toHaveBeenCalledWith(['1', '2', 'den']);
+    expect(comboboxTester.combobox).toHaveValue('');
+  });
+
+  it('should deselect custom value when typing it again in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('Test');
+    await user.tab();
+    expect(onChange).toHaveBeenCalledWith(['Test']);
+
+    onChange.mockClear();
+    await user.click(comboboxTester.combobox);
+    await user.keyboard('Test');
+    await user.tab();
+    // Should deselect "Test"
+    expect(onChange).toHaveBeenCalledWith([]);
+  });
+
+  it('should deselect custom value when typing it again and pressing Enter in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox defaultValue={['Custom']} selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('Custom');
+    await user.keyboard('{Enter}');
+    // Should deselect "Custom"
+    expect(onChange).toHaveBeenCalledWith([]);
+    expect(comboboxTester.combobox).toHaveValue('');
+  });
+
+  it('should not add empty custom values in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('   ');
+    await user.tab();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('should select existing item instead of creating custom value when input matches item text in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    await user.keyboard('Cat');
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    await user.tab();
+    // Should select the existing "Cat" item (id: '1'), not create a custom "Cat" value
+    expect(onChange).toHaveBeenCalledWith(['1']);
+    expect(comboboxTester.combobox).toHaveValue('');
+  });
+
+  it('should clear input when selecting an item from the list in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await comboboxTester.open();
+    await user.keyboard('C');
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    // Arrow down to first item and select it
+    await user.keyboard('{ArrowDown}{Enter}');
+    expect(onChange).toHaveBeenCalledWith(['1']);
+    expect(comboboxTester.combobox).toHaveValue('');
+  });
+
+  it('should submit custom values in form data for multi-select with allowsCustomValue', async () => {
+    let {container} = render(
+      <Form data-testid="form">
+        <ComboBox name="combobox" selectionMode="multiple" allowsCustomValue allowsEmptyCollection>
+          <Label>Favorite Animal</Label>
+          <Input />
+          <Button />
+          <Popover>
+            <ListBox>
+              <ListBoxItem id="1">Cat</ListBoxItem>
+              <ListBoxItem id="2">Dog</ListBoxItem>
+            </ListBox>
+          </Popover>
+        </ComboBox>
+      </Form>
+    );
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    // Select an existing item
+    await comboboxTester.open();
+    await user.keyboard('{ArrowDown}{Enter}');
+
+    // Add a custom value
+    await user.keyboard('Unicorn');
+    await user.tab();
+
+    let hiddenInputs = container.querySelectorAll('input[type="hidden"]');
+    expect(hiddenInputs).toHaveLength(2);
+    expect(hiddenInputs[0]).toHaveAttribute('name', 'combobox');
+    expect(hiddenInputs[0]).toHaveAttribute('value', '1');
+    expect(hiddenInputs[1]).toHaveAttribute('name', 'combobox');
+    expect(hiddenInputs[1]).toHaveAttribute('value', 'Unicorn');
+  });
+
+  it('should match item with trimmed input in multi-select with allowsCustomValue', async () => {
+    let onChange = jest.fn();
+    let {container} = render(<TestComboBox selectionMode="multiple" allowsCustomValue onChange={onChange} />);
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    // Type item name with surrounding whitespace
+    await user.keyboard('  Cat  ');
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    await user.tab();
+    // Should select the existing "Cat" item (id: '1'), not create a custom " Cat " value
+    expect(onChange).toHaveBeenCalledWith(['1']);
+    expect(comboboxTester.combobox).toHaveValue('');
+  });
+
+  it('should add custom value as-is when typed text collides with an existing item key in multi-select', async () => {
+    let onChange = jest.fn();
+    let {container} = render(
+      <ComboBox selectionMode="multiple" allowsCustomValue allowsEmptyCollection onChange={onChange}>
+        <Label>State</Label>
+        <Input />
+        <Button />
+        <ComboBoxValue placeholder="No items selected" />
+        <Popover>
+          <ListBox>
+            <ListBoxItem id="NY">New York</ListBoxItem>
+            <ListBoxItem id="CA">California</ListBoxItem>
+          </ListBox>
+        </Popover>
+      </ComboBox>
+    );
+    let comboboxTester = testUtilUser.createTester('ComboBox', {root: container});
+
+    await user.tab();
+    // "NY" matches an item's id but not any item's textValue ("New York", "California")
+    await user.keyboard('NY');
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    await user.tab();
+    // Should add "NY" as a custom value, NOT select the New York item (whose id is 'NY')
+    let value = container.querySelector('.react-aria-ComboBoxValue');
+    expect(value).toHaveTextContent('NY');
+    expect(value).not.toHaveTextContent('New York');
+    expect(comboboxTester.combobox).toHaveValue('');
   });
 
   it('should allow the user to deselect items with keyboard when multiselect (uncontrolled)', async () => {
diff --git a/packages/react-aria/src/collections/BaseCollection.ts b/packages/react-aria/src/collections/BaseCollection.ts
index 70c55c859fe..c0253bc8faa 100644
--- a/packages/react-aria/src/collections/BaseCollection.ts
+++ b/packages/react-aria/src/collections/BaseCollection.ts
@@ -47,7 +47,8 @@ export class CollectionNode<T> implements Node<T> {
   }
 
   get childNodes(): Iterable<Node<T>> {
-    throw new Error('childNodes is not supported');
+    console.warn('childNodes is not supported. Use collection.getChildren(key) instead.');
+    return [];
   }
 
   clone(): this {
diff --git a/packages/react-stately/src/combobox/useComboBoxState.ts b/packages/react-stately/src/combobox/useComboBoxState.ts
index 02f6bd0116c..73c70cf9d4b 100644
--- a/packages/react-stately/src/combobox/useComboBoxState.ts
+++ b/packages/react-stately/src/combobox/useComboBoxState.ts
@@ -147,7 +147,24 @@ export interface ComboBoxStateOptions<T, M extends SelectionMode = 'single'> ext
   shouldCloseOnBlur?: boolean
 }
 
-const EMPTY_VALUE: Key[] = [];
+function createCustomNode<T>(key: Key): Node<T> {
+  return {
+    type: 'item',
+    key,
+    value: null,
+    level: 0,
+    hasChildNodes: false,
+    childNodes: [],
+    rendered: String(key),
+    textValue: String(key),
+    'aria-label': undefined,
+    index: -1,
+    parentKey: null,
+    prevKey: null,
+    nextKey: null,
+    props: {isCustomValue: true}
+  };
+}
 
 /**
  * Provides state management for a combo box component. Handles building a collection
@@ -167,6 +184,10 @@ export function useComboBoxState<T extends object, M extends SelectionMode = 'si
   let [showAllItems, setShowAllItems] = useState(false);
   let [isFocused, setFocusedState] = useState(false);
   let [focusStrategy, setFocusStrategy] = useState<FocusStrategy | null>(null);
+  // Tracks keys that were added via commitCustomValue so we can distinguish them
+  // from real item keys that happen to have the same string (e.g. typing "NY" when
+  // there is an item with id "NY" and textValue "New York").
+  let [customKeys, setCustomKeys] = useState<Set<Key>>(() => new Set());
 
   let defaultValue = useMemo(() => {
     return props.defaultValue !== undefined ? props.defaultValue : (selectionMode === 'single' ? props.defaultSelectedKey ?? null : []) as ValueType<M>;
@@ -226,15 +247,32 @@ export function useComboBoxState<T extends object, M extends SelectionMode = 'si
           setValue(key);
         }
       } else {
-        setValue([...keys]);
+        let newKeys = [...keys];
+        let prevKeys = Array.isArray(displayValue) ? displayValue as Key[] : [];
+        setValue(newKeys);
+        // Clear input when an item is added (not when deselected)
+        if (newKeys.length > prevKeys.length) {
+          setInputValue('');
+        }
       }
     }
   });
 
   let selectedKey = selectionMode === 'single' ? selectionManager.firstSelectedKey : null;
   let selectedItems = useMemo(() => {
-    return [...selectionManager.selectedKeys].map(key => collection.getItem(key)).filter(item => item != null);
-  }, [selectionManager.selectedKeys, collection]);
+    return [...selectionManager.selectedKeys].map(key => {
+      // If the key was added as a custom value, render it as custom even if the
+      // collection happens to contain an item with the same key.
+      if (customKeys.has(key)) {
+        return createCustomNode<T>(key);
+      }
+      let item = collection.getItem(key);
+      if (item == null) {
+        return allowsCustomValue ? createCustomNode<T>(key) : null;
+      }
+      return item;
+    }).filter(item => item != null);
+  }, [selectionManager.selectedKeys, collection, allowsCustomValue, customKeys]);
 
   let [inputValue, setInputValue] = useControlledState(
     props.inputValue,
@@ -418,7 +456,11 @@ export function useComboBoxState<T extends object, M extends SelectionMode = 'si
 
   // Revert input value and close menu
   let revert = () => {
-    if (allowsCustomValue && selectedKey == null) {
+    if (selectionMode === 'multiple') {
+      // In multi-select, revert just clears input without changing selection
+      setInputValue('');
+      closeMenu();
+    } else if (allowsCustomValue && selectedKey == null) {
       commitCustomValue();
     } else {
       commitSelection();
@@ -426,9 +468,36 @@ export function useComboBoxState<T extends object, M extends SelectionMode = 'si
   };
 
   let commitCustomValue = () => {
-    let value = selectionMode === 'multiple' ? EMPTY_VALUE : null;
-    lastValueRef.current = value as any;
-    setValue(value);
+    lastValueRef.current = null as any;
+    if (selectionMode === 'single') {
+      setValue(null);
+    } else {
+      let trimmed = inputValue.trim();
+      if (trimmed === '') {
+        closeMenu();
+        return;
+      }
+      let current: Key[] = Array.isArray(displayValue) ? displayValue as Key[] : [];
+      if (current.includes(trimmed)) {
+        setValue(current.filter(v => v !== trimmed));
+        setCustomKeys(prev => {
+          if (!prev.has(trimmed)) {
+            return prev;
+          }
+          let next = new Set(prev);
+          next.delete(trimmed);
+          return next;
+        });
+      } else {
+        setValue([...current, trimmed]);
+        setCustomKeys(prev => {
+          let next = new Set(prev);
+          next.add(trimmed);
+          return next;
+        });
+      }
+      setInputValue('');
+    }
     closeMenu();
   };
 
@@ -456,13 +525,42 @@ export function useComboBoxState<T extends object, M extends SelectionMode = 'si
     }
   };
 
+  let findItemCaseInsensitive = (text: string): Node<T> | undefined => {
+    let lower = text.toLowerCase();
+    return [...collection].find(item => item.textValue?.toLowerCase() === lower);
+  };
+
   const commitValue = () => {
     if (allowsCustomValue) {
-      const itemText = selectedKey != null ? collection.getItem(selectedKey)?.textValue ?? '' : '';
-      (inputValue === itemText) ? commitSelection() : commitCustomValue();
+      if (selectionMode === 'single') {
+        let matchingItem = inputValue ? findItemCaseInsensitive(inputValue) : undefined;
+        if (matchingItem) {
+          selectionManager.select(matchingItem.key);
+          closeMenu();
+        } else {
+          commitCustomValue();
+        }
+      } else {
+        // In multi-select, check if input matches any item's textValue (case insensitive)
+        let trimmedInput = inputValue.trim();
+        let matchingItem = trimmedInput ? findItemCaseInsensitive(trimmedInput) : undefined;
+        if (matchingItem) {
+          selectionManager.select(matchingItem.key);
+          setInputValue('');
+          closeMenu();
+        } else {
+          commitCustomValue();
+        }
+      }
     } else {
-      // Reset inputValue and close menu
-      commitSelection();
+      // Check if input matches an existing item case-insensitively
+      let matchingItem = inputValue ? findItemCaseInsensitive(inputValue) : undefined;
+      if (matchingItem) {
+        selectionManager.select(matchingItem.key);
+        closeMenu();
+      } else {
+        commitSelection();
+      }
     }
   };