diff --git a/.changeset/suggestion-menu-no-results.md b/.changeset/suggestion-menu-no-results.md
new file mode 100644
index 00000000..49a02fca
--- /dev/null
+++ b/.changeset/suggestion-menu-no-results.md
@@ -0,0 +1,5 @@
+---
+'@bazza-ui/react': minor
+---
+
+Add `noResults` to `SuggestionMenu.Root`. With `'empty'` (the default) the menu stays open and shows `Empty` when nothing matches, and Enter reaches the host input. With `'close'` the menu closes once every search for the query has finished empty (reason `'no-results'`), before the empty popup is painted. An `update()` with the same query leaves it closed, for example when only the caret moved. An `update()` with any other query searches again. `SuggestionMenu.useAsyncMenuCoordinator` is available for showing a "searching…" indicator while results refetch.
diff --git a/packages/react/src/suggestion-menu/events.ts b/packages/react/src/suggestion-menu/events.ts
index 7044eda5..a741c494 100644
--- a/packages/react/src/suggestion-menu/events.ts
+++ b/packages/react/src/suggestion-menu/events.ts
@@ -16,6 +16,7 @@ import type {
  * - `escape-key`: Escape was pressed in the host input
  * - `outside-press`: a press outside the popup and the host input
  * - `focus-out`: the host input lost focus
+ * - `no-results`: with `noResults: 'close'`, the results settled empty
  */
 export type SuggestionMenuOpenChangeReason =
   | typeof REASONS.imperativeAction
@@ -23,6 +24,7 @@ export type SuggestionMenuOpenChangeReason =
   | typeof REASONS.escapeKey
   | typeof REASONS.outsidePress
   | typeof REASONS.focusOut
+  | typeof REASONS.noResults
   | typeof REASONS.none
 
 /**
diff --git a/packages/react/src/suggestion-menu/handle.ts b/packages/react/src/suggestion-menu/handle.ts
index 8b3b0893..749724bf 100644
--- a/packages/react/src/suggestion-menu/handle.ts
+++ b/packages/react/src/suggestion-menu/handle.ts
@@ -128,7 +128,11 @@ export class SuggestionMenuHandle<Payload = unknown> {
     if (!this.isOpen) this.#requestOpen(true)
   }
 
-  /** Closes the menu. */
+  /**
+   * Closes the menu. Call it whenever the trigger ends (deleted, or the caret
+   * left it), even if the menu is already closed: it also resets what the
+   * menu remembers about the trigger, such as a query that had no results.
+   */
   close(): void {
     this.#requestOpen(false)
   }
diff --git a/packages/react/src/suggestion-menu/root/root.tsx b/packages/react/src/suggestion-menu/root/root.tsx
index 5300691c..6e310e5c 100644
--- a/packages/react/src/suggestion-menu/root/root.tsx
+++ b/packages/react/src/suggestion-menu/root/root.tsx
@@ -3,6 +3,7 @@
 import { Popover, type PopoverRootProps } from '@base-ui/react/popover'
 import * as React from 'react'
 import type { ListboxStore, VirtualItem } from '../../internal/listbox/index.js'
+import type { PopupMenuOpenChangeReason } from '../../internal/popup-menu/events.js'
 import {
   type ForwardKeyDown,
   type PopupMenuHighlightChangeHandler,
@@ -110,6 +111,16 @@ export interface SuggestionMenuRootProps<Payload = unknown>
    * @default (count, label) => count === 0 ? 'No results' : `${count} results, first: ${label}`
    */
   getAriaResultsText?: GetAriaResultsText
+  /**
+   * What happens when nothing matches the query, once every search for it has
+   * finished.
+   * - `'empty'`: the menu stays open and shows `Empty`; Enter reaches the host.
+   * - `'close'`: the menu closes (reason `'no-results'`). An `update()` with
+   *   the same query leaves it closed; one with any other query searches
+   *   again.
+   * @default 'empty'
+   */
+  noResults?: 'empty' | 'close'
   /** The menu's parts, or a function of the payload and query that returns them. */
   children:
     | React.ReactNode
@@ -169,6 +180,7 @@ export function SuggestionMenuRoot<Payload = unknown>(
     getResolvedId,
     idScope = 'surface',
     getAriaResultsText = defaultGetAriaResultsText,
+    noResults = 'empty',
     children,
     ...rest
   } = props
@@ -234,6 +246,13 @@ export function SuggestionMenuRoot<Payload = unknown>(
   handleOpenChangeRef.current = handleOpenChange
   const forwardKeyDownRef = React.useRef<ForwardKeyDown | null>(null)
   const detachHostRef = React.useRef<(() => void) | null>(null)
+  // With `noResults: 'close'`: the query whose results settled empty.
+  const emptyQueryRef = React.useRef<string | null>(null)
+  const noResultsRef = React.useRef(noResults)
+  noResultsRef.current = noResults
+  const queryPropRef = React.useRef(queryProp)
+  queryPropRef.current = queryProp
+  const openOnQueryChangeRef = React.useRef(false)
 
   // `aria-activedescendant` follows keyboard highlight only (ADR 0005). Set
   // when the menu moves the highlight for a key; cleared when the query
@@ -249,7 +268,31 @@ export function SuggestionMenuRoot<Payload = unknown>(
       nextOpen: boolean,
       reason: SuggestionMenuOpenChangeReason,
       event?: Event,
-    ) => handleOpenChangeRef.current(nextOpen, reason, event)
+    ) => {
+      if (reason === REASONS.imperativeAction) {
+        const empty = emptyQueryRef.current
+        if (nextOpen && empty !== null) {
+          // The query that settled empty stays closed (e.g. only the caret
+          // moved); any other query searches again. A controlled query may
+          // not have rendered yet, so that open waits for it.
+          const controlled = queryPropRef.current
+          if (controlled === empty) {
+            openOnQueryChangeRef.current = true
+            return
+          }
+          if (controlled === undefined && handle.getState().query === empty) {
+            return
+          }
+        }
+        emptyQueryRef.current = null
+        openOnQueryChangeRef.current = false
+      }
+      handleOpenChangeRef.current(
+        nextOpen,
+        reason as PopupMenuOpenChangeReason,
+        event,
+      )
+    }
 
     // While a row is being chosen (Enter, or a click on a row), a `close()`
     // from the row's `onSelect` waits, so the menu's own close reports
@@ -310,6 +353,9 @@ export function SuggestionMenuRoot<Payload = unknown>(
         })
       },
       attachHost: (host) => {
+        // A new host (or none) starts fresh.
+        emptyQueryRef.current = null
+        openOnQueryChangeRef.current = false
         detachHostRef.current?.()
         detachHostRef.current = host
           ? watchHost(host, {
@@ -338,6 +384,19 @@ export function SuggestionMenuRoot<Payload = unknown>(
   }
 
   const query = queryProp ?? handleState.query
+  // An open that waited for a controlled query to leave the empty one. The
+  // prop can render after the `update()` (e.g. state set from an editor's
+  // native listener), so it waits until the next `update()`, `close()` or
+  // host change.
+  React.useLayoutEffect(() => {
+    if (!openOnQueryChangeRef.current || query === emptyQueryRef.current) return
+    openOnQueryChangeRef.current = false
+    emptyQueryRef.current = null
+    handleOpenChangeRef.current(
+      true,
+      REASONS.imperativeAction as PopupMenuOpenChangeReason,
+    )
+  }, [query])
   const anchor = anchorProp ?? handleState.anchor
   const payload = handleState.payload
   const host = handleState.host
@@ -367,6 +426,14 @@ export function SuggestionMenuRoot<Payload = unknown>(
   getAriaResultsTextRef.current = getAriaResultsText
   const reportResults = React.useCallback(
     (count: number, label: string | null) => {
+      if (count === 0 && noResultsRef.current === 'close') {
+        emptyQueryRef.current = queryRef.current
+        handleOpenChangeRef.current(
+          false,
+          REASONS.noResults as PopupMenuOpenChangeReason,
+        )
+        return
+      }
       const text = getAriaResultsTextRef.current(count, label)
       setAnnouncement((current) => ({ text, key: (current?.key ?? 0) + 1 }))
     },
@@ -407,7 +474,7 @@ export function SuggestionMenuRoot<Payload = unknown>(
     (nextOpen: boolean, details: Popover.Root.ChangeEventDetails) => {
       handleOpenChange(
         nextOpen,
-        details.reason as SuggestionMenuOpenChangeReason,
+        details.reason as PopupMenuOpenChangeReason,
         details.event,
       )
     },
diff --git a/packages/react/src/suggestion-menu/suggestion-menu.no-results.test.tsx b/packages/react/src/suggestion-menu/suggestion-menu.no-results.test.tsx
new file mode 100644
index 00000000..12f3492e
--- /dev/null
+++ b/packages/react/src/suggestion-menu/suggestion-menu.no-results.test.tsx
@@ -0,0 +1,373 @@
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import * as React from 'react'
+import { describe, expect, it, vi } from 'vitest'
+import type {
+  ItemDef,
+  NodeDef,
+  QueryLoaderConfig,
+} from '../internal/popup-menu/index.js'
+import { createVanillaQueryLoader } from '../loaders/vanilla.js'
+import { SuggestionMenu } from './index.js'
+
+function Rows() {
+  const { nodes, renderNode } = SuggestionMenu.useDataList()
+  return <>{nodes.map(renderNode)}</>
+}
+
+const item = (value: string): ItemDef => ({
+  kind: 'item',
+  value,
+  render: ({ props }) => (
+    <SuggestionMenu.Item {...props} data-testid={value}>
+      {value}
+    </SuggestionMenu.Item>
+  ),
+})
+
+function setup(
+  options: {
+    noResults?: 'empty' | 'close'
+    content?: ItemDef[]
+    asyncContent?: QueryLoaderConfig
+  } = {},
+) {
+  const menu = SuggestionMenu.createHandle()
+  const onOpenChange = vi.fn()
+  const keys: boolean[] = []
+  render(
+    <>
+      <textarea
+        data-testid="host"
+        ref={(el) => {
+          if (el) menu.attach(el)
+        }}
+        onKeyDown={(event) => keys.push(menu.handleKeyDown(event))}
+      />
+      <SuggestionMenu.Root
+        handle={menu}
+        noResults={options.noResults}
+        onOpenChange={onOpenChange}
+      >
+        <SuggestionMenu.Portal>
+          <SuggestionMenu.Positioner>
+            <SuggestionMenu.Popup data-testid="popup">
+              <SuggestionMenu.Surface
+                content={options.content ?? [item('Alice'), item('Bob')]}
+                asyncContent={options.asyncContent}
+              >
+                <SuggestionMenu.List>
+                  <Rows />
+                </SuggestionMenu.List>
+                <SuggestionMenu.Empty data-testid="empty">
+                  Nobody
+                </SuggestionMenu.Empty>
+              </SuggestionMenu.Surface>
+            </SuggestionMenu.Popup>
+          </SuggestionMenu.Positioner>
+        </SuggestionMenu.Portal>
+      </SuggestionMenu.Root>
+    </>,
+  )
+  const reasons = () =>
+    onOpenChange.mock.calls.map(([open, details]) => [open, details.reason])
+  return { menu, host: screen.getByTestId('host'), keys, reasons }
+}
+
+const popup = () => screen.queryByTestId('popup')
+const tick = () => new Promise((resolve) => setTimeout(resolve, 20))
+
+describe("SuggestionMenu noResults: 'empty'", () => {
+  it('stays open, shows Empty, and lets Enter reach the host', async () => {
+    const { menu, host, keys } = setup()
+    act(() => menu.update({ query: 'zz' }))
+
+    expect(await screen.findByTestId('empty')).toBeInTheDocument()
+    await tick()
+    expect(popup()).toBeInTheDocument()
+
+    act(() => {
+      fireEvent.keyDown(host, { key: 'Enter' })
+    })
+    expect(keys.at(-1)).toBe(false)
+  })
+})
+
+describe("SuggestionMenu noResults: 'close'", () => {
+  it('closes once the results settle empty', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'a' }))
+    await screen.findByTestId('Alice')
+
+    act(() => menu.update({ query: 'az' }))
+
+    await waitFor(() => expect(popup()).not.toBeInTheDocument())
+    expect(reasons().at(-1)).toEqual([false, 'no-results'])
+  })
+
+  it('closes before the browser paints the empty popup', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'a' }))
+    await screen.findByTestId('Alice')
+
+    act(() => menu.update({ query: 'az' }))
+    // Microtasks only: no timer or frame has run.
+    await Promise.resolve()
+
+    expect(reasons().at(-1)).toEqual([false, 'no-results'])
+  })
+
+  it('waits for the loaders before deciding', async () => {
+    const pending = new Map<string, (rows: NodeDef[]) => void>()
+    const loader = createVanillaQueryLoader({
+      fetcher: (query: string) =>
+        new Promise<NodeDef[]>((resolve) => pending.set(query, resolve)),
+      minQueryLength: 0,
+    })
+    const { menu } = setup({
+      noResults: 'close',
+      content: [],
+      asyncContent: loader,
+    })
+    act(() => menu.update({ query: 'da' }))
+    await screen.findByTestId('popup')
+    await tick()
+    expect(popup()).toBeInTheDocument()
+
+    await act(async () => {
+      pending.get('da')?.([item('Dana')])
+    })
+
+    expect(await screen.findByTestId('Dana')).toBeInTheDocument()
+    await tick()
+    expect(popup()).toBeInTheDocument()
+  })
+
+  it('stays closed on updates with the same query', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'az' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+    const calls = reasons().length
+
+    // Only the caret moved.
+    act(() => menu.update({ query: 'az', anchor: () => new DOMRect() }))
+    await tick()
+
+    expect(popup()).not.toBeInTheDocument()
+    expect(reasons()).toHaveLength(calls)
+  })
+
+  it('searches again when the user keeps typing', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'az' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+
+    act(() => menu.update({ query: 'azb' }))
+
+    expect(reasons().at(-1)).toEqual([true, 'imperative-action'])
+  })
+
+  it('opens for a longer query after an empty one settled empty', async () => {
+    const loader = createVanillaQueryLoader({
+      fetcher: async (query: string) => (query ? [item('Alice')] : []),
+      minQueryLength: 0,
+    })
+    const { menu, reasons } = setup({
+      noResults: 'close',
+      content: [],
+      asyncContent: loader,
+    })
+    act(() => menu.update({ query: '' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+
+    act(() => menu.update({ query: 'a' }))
+
+    expect(await screen.findByTestId('Alice')).toBeInTheDocument()
+  })
+
+  it('opens when a controlled query moves off the empty one', async () => {
+    const menu = SuggestionMenu.createHandle()
+    const onOpenChange = vi.fn()
+    let setQuery: (query: string) => void = () => {}
+    function Controlled() {
+      const [query, set] = React.useState('')
+      setQuery = set
+      return (
+        <SuggestionMenu.Root
+          handle={menu}
+          query={query}
+          noResults="close"
+          onOpenChange={onOpenChange}
+        >
+          <SuggestionMenu.Portal>
+            <SuggestionMenu.Positioner>
+              <SuggestionMenu.Popup data-testid="popup">
+                <SuggestionMenu.Surface content={[item('Alice')]}>
+                  <SuggestionMenu.List>
+                    <Rows />
+                  </SuggestionMenu.List>
+                </SuggestionMenu.Surface>
+              </SuggestionMenu.Popup>
+            </SuggestionMenu.Positioner>
+          </SuggestionMenu.Portal>
+        </SuggestionMenu.Root>
+      )
+    }
+    render(<Controlled />)
+    act(() => {
+      setQuery('az')
+      menu.update({})
+    })
+    await waitFor(() =>
+      expect(onOpenChange).toHaveBeenLastCalledWith(
+        false,
+        expect.objectContaining({ reason: 'no-results' }),
+      ),
+    )
+
+    // The caret moved: same query, so it stays closed.
+    const calls = onOpenChange.mock.calls.length
+    act(() => menu.update({}))
+    await tick()
+    expect(onOpenChange.mock.calls).toHaveLength(calls)
+    expect(popup()).not.toBeInTheDocument()
+
+    // Backspace: the host sets the query and updates the menu in one go.
+    act(() => {
+      setQuery('a')
+      menu.update({})
+    })
+
+    expect(await screen.findByTestId('Alice')).toBeInTheDocument()
+  })
+
+  it('opens again on any other query', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'az' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+
+    // Backspace back to a query with results.
+    act(() => menu.update({ query: 'a' }))
+
+    expect(await screen.findByTestId('Alice')).toBeInTheDocument()
+    expect(reasons().at(-1)).toEqual([true, 'imperative-action'])
+  })
+
+  it("doesn't open later from a same-query update", async () => {
+    const menu = SuggestionMenu.createHandle()
+    const onOpenChange = vi.fn()
+    let setQuery: (query: string) => void = () => {}
+    function Controlled() {
+      const [query, set] = React.useState('')
+      setQuery = set
+      return (
+        <SuggestionMenu.Root
+          handle={menu}
+          query={query}
+          noResults="close"
+          onOpenChange={onOpenChange}
+        >
+          <SuggestionMenu.Portal>
+            <SuggestionMenu.Positioner>
+              <SuggestionMenu.Popup data-testid="popup">
+                <SuggestionMenu.Surface content={[item('Alice')]}>
+                  <SuggestionMenu.List>
+                    <Rows />
+                  </SuggestionMenu.List>
+                </SuggestionMenu.Surface>
+              </SuggestionMenu.Popup>
+            </SuggestionMenu.Positioner>
+          </SuggestionMenu.Portal>
+        </SuggestionMenu.Root>
+      )
+    }
+    render(<Controlled />)
+    act(() => {
+      setQuery('az')
+      menu.update({})
+    })
+    await waitFor(() =>
+      expect(onOpenChange).toHaveBeenLastCalledWith(
+        false,
+        expect.objectContaining({ reason: 'no-results' }),
+      ),
+    )
+    act(() => menu.update({}))
+
+    // Later, the trigger is deleted: the host closes and resets its query.
+    act(() => menu.close())
+    const calls = onOpenChange.mock.calls.length
+    act(() => setQuery(''))
+    await tick()
+
+    expect(onOpenChange.mock.calls).toHaveLength(calls)
+    expect(popup()).not.toBeInTheDocument()
+  })
+
+  it('opens when a controlled query renders after the update', async () => {
+    const menu = SuggestionMenu.createHandle()
+    let setQuery: (query: string) => void = () => {}
+    function Controlled() {
+      const [query, set] = React.useState('')
+      setQuery = set
+      return (
+        <SuggestionMenu.Root handle={menu} query={query} noResults="close">
+          <SuggestionMenu.Portal>
+            <SuggestionMenu.Positioner>
+              <SuggestionMenu.Popup data-testid="popup">
+                <SuggestionMenu.Surface content={[item('Alice')]}>
+                  <SuggestionMenu.List>
+                    <Rows />
+                  </SuggestionMenu.List>
+                </SuggestionMenu.Surface>
+              </SuggestionMenu.Popup>
+            </SuggestionMenu.Positioner>
+          </SuggestionMenu.Portal>
+        </SuggestionMenu.Root>
+      )
+    }
+    render(<Controlled />)
+    act(() => {
+      setQuery('az')
+      menu.update({})
+    })
+    await waitFor(() => expect(popup()).not.toBeInTheDocument())
+
+    // Backspace: the editor's listener updates the menu first; its query
+    // state renders separately.
+    act(() => menu.update({}))
+    act(() => setQuery('a'))
+
+    expect(await screen.findByTestId('Alice')).toBeInTheDocument()
+  })
+
+  it('forgets the empty query when the host changes', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'az' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+
+    act(() => {
+      menu.attach(document.createElement('textarea'))
+    })
+    act(() => menu.update({ query: 'az' }))
+
+    expect(reasons().at(-1)).toEqual([true, 'imperative-action'])
+  })
+
+  it('forgets the empty query when the trigger ends', async () => {
+    const { menu, reasons } = setup({ noResults: 'close' })
+    act(() => menu.update({ query: 'az' }))
+    await waitFor(() => expect(reasons().at(-1)).toEqual([false, 'no-results']))
+
+    // The trigger was deleted, then typed again with the same text.
+    act(() => menu.close())
+    act(() => menu.update({ query: 'az' }))
+
+    expect(reasons().at(-1)).toEqual([true, 'imperative-action'])
+  })
+})
+
+describe('SuggestionMenu exports', () => {
+  it('re-exports the async coordinator hook', () => {
+    expect(typeof SuggestionMenu.useAsyncMenuCoordinator).toBe('function')
+  })
+})
diff --git a/packages/react/src/suggestion-menu/surface/results-reporter.tsx b/packages/react/src/suggestion-menu/surface/results-reporter.tsx
index 10267310..94166867 100644
--- a/packages/react/src/suggestion-menu/surface/results-reporter.tsx
+++ b/packages/react/src/suggestion-menu/surface/results-reporter.tsx
@@ -52,12 +52,14 @@ export function SuggestionMenuResultsReporter() {
   }
   const menuHighlightedId = menuHighlightRef.current
 
-  React.useEffect(() => {
+  React.useLayoutEffect(() => {
     if (!open || !settled) return undefined
-    // Read the rows once this update has finished: a settle published from a
-    // layout effect re-renders first, and cancels this timer if the results
-    // turned out not to be settled after all.
-    const timeout = setTimeout(() => {
+    // Read the rows once this update has finished, still before paint: a
+    // settle published from a layout effect re-renders first, and cancels
+    // this if the results turned out not to be settled after all.
+    let cancelled = false
+    queueMicrotask(() => {
+      if (cancelled) return
       const ids = store.getVisibleItemIds()
       // The row Enter would choose: the highlighted one, if any.
       const current = store.state.highlightedId
@@ -67,7 +69,9 @@ export function SuggestionMenuResultsReporter() {
         chosen ? rowLabel(store, chosen) : null,
       )
     })
-    return () => clearTimeout(timeout)
+    return () => {
+      cancelled = true
+    }
   }, [open, settled, query, menuHighlightedId, store, reportResults])
 
   return null
diff --git a/packages/react/src/utils/events/reason-parts.ts b/packages/react/src/utils/events/reason-parts.ts
index f672382f..d3c044ca 100644
--- a/packages/react/src/utils/events/reason-parts.ts
+++ b/packages/react/src/utils/events/reason-parts.ts
@@ -41,4 +41,6 @@ export const auto = 'auto' as const
 
 // Programmatic/other
 export const imperativeAction = 'imperative-action' as const
+/** A suggestion menu's results settled empty with `noResults: 'close'`. */
+export const noResults = 'no-results' as const
 export const none = 'none' as const