@@ -1,10 +1,9 @@
 import * as readline from 'node:readline';
 import { AsyncResource } from 'node:async_hooks';
-import { type Prompt } from '@inquirer/type';
+import { type Prompt, withResolver } from '@inquirer/type';
 import MuteStream from 'mute-stream';
 import { onExit as onSignalExit } from 'signal-exit';
 import ScreenManager from './screen-manager.ts';
-import { PromisePolyfill } from './promise-polyfill.ts';
 import { type InquirerReadline } from '@inquirer/type';
 import { withHooks, effectScheduler } from './hook-engine.ts';
 import { AbortPromptError, CancelPromptError, ExitPromptError } from './errors.ts';
@@ -98,7 +97,7 @@ export function createPrompt<Value, Config>(
     output.mute();
     const screen = new ScreenManager(rl);
 
-    const { promise, resolve, reject } = PromisePolyfill.withResolver<Value>();
+    const { promise, resolve, reject } = withResolver<Value>();
 
     return withHooks(rl, (cycle) => {
       // Clear hook effects synchronously before the prompt settles: readline
 
@@ -1,5 +1,6 @@
-import { describe, it, expect, expectTypeOf } from 'vitest';
+import { describe, it, expect, expectTypeOf, vi } from 'vitest';
 import { render } from '@inquirer/testing';
+import { withResolver } from '@inquirer/type';
 import search, { Separator } from './src/index.ts';
 
 // Array of all countries names as string
@@ -39,6 +40,52 @@ function getListSearch(
 }
 
 describe('search prompt', () => {
+  it('does not submit stale choices and keeps the search term while a search is pending', async () => {
+    const { promise: resultsPromise, resolve: resolveResults } =
+      withResolver<Array<string>>();
+    const terms: Array<string | undefined> = [];
+    const { answer, events, nextRender } = await render(search, {
+      message: 'Select a Canadian province',
+      source: (term: string | undefined) => {
+        terms.push(term);
+        return term ? resultsPromise : ['Alberta'];
+      },
+    });
+
+    // A first enter while the search for "Que" is still pending must not
+    // submit any stale choice.
+    events.type('Que');
+    await nextRender();
+    events.keypress('enter');
+
+    // The search term must survive the enter keypress.
+    events.type('bec');
+    await nextRender();
+
+    resolveResults(['Quebec']);
+    await nextRender();
+    events.keypress('enter');
+    await expect(answer).resolves.toEqual('Quebec');
+    expect(terms.at(-1)).toBe('Quebec');
+  });
+
+  it('does not start another validation while one is pending', async () => {
+    const { promise: validation, resolve: resolveValidation } = withResolver<boolean>();
+    const validate = vi.fn(() => validation);
+    const { answer, events } = await render(search, {
+      message: 'Select a Canadian province',
+      source: () => ['Quebec'],
+      validate,
+    });
+
+    events.keypress('enter');
+    events.keypress('enter');
+    resolveValidation(true);
+
+    await expect(answer).resolves.toEqual('Quebec');
+    expect(validate).toHaveBeenCalledOnce();
+  });
+
   it('allows to search', async () => {
     const { answer, events, getScreen, nextRender } = await render(search, {
       message: 'Select a Canadian province',
 
@@ -190,7 +190,7 @@ export default createPrompt(
 
     useKeypress(async (key, rl) => {
       if (isEnterKey(key)) {
-        if (selectedChoice) {
+        if (selectedChoice && status === 'idle') {
           setStatus('loading');
           const isValid = await validate(selectedChoice.value);
           setStatus('idle');
 
@@ -0,0 +1,14 @@
+import { test, expect } from 'vitest';
+import { withResolver } from './utils.ts';
+
+test('withResolver resolves the returned promise', async () => {
+  const { promise, resolve } = withResolver<string>();
+  resolve('foo');
+  await expect(promise).resolves.toBe('foo');
+});
+
+test('withResolver rejects the returned promise', async () => {
+  const { promise, reject } = withResolver<string>();
+  reject(new Error('bar'));
+  await expect(promise).rejects.toThrow('bar');
+});
@@ -59,3 +59,24 @@ export type _Pick<O extends object, K extends Key> = __Pick<O, keyof O & K>;
 export type Pick<O extends object, K extends Key> = O extends unknown
   ? _Pick<O, K>
   : never;
+
+/**
+ * Create a promise and get access to its `resolve` and `reject` functions.
+ *
+ * Mirrors `Promise.withResolvers()`, available starting from Node 22.
+ * TODO: Remove once Node 22 becomes the minimum supported version.
+ */
+export function withResolver<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: unknown) => void;
+} {
+  let resolve: (value: T) => void;
+  let reject: (error: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve: resolve!, reject: reject! };
+}