fix(@inquirer/core): discard keystrokes buffered before prompt creation

Defer the first render cycle by one setImmediate tick for proper Readable
streams (like process.stdin) so that OS-level buffered data flows through
readline harmlessly before any keypress handlers are registered. Pre-mute
the output to suppress stale keystroke echoing during the drain period.

Old-style streams (like MuteStream) have no OS-level buffering, so the
render cycle starts immediately as before.

Closes #1303

Author: SBoudrias

packages/core/core.test.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'node:stream';
+import { EventEmitter, PassThrough } from 'node:stream';
 import { describe, it, expect, vi } from 'vitest';
 import { render } from '@inquirer/testing';
 import { stripVTControlCharacters } from 'node:util';
@@ -576,6 +576,41 @@ it('allow aborting the prompt using signals', async () => {
   await expect(answer).rejects.toThrow(AbortPromptError);
 });
 
+it('should ignore keypresses buffered before prompt creation', async () => {
+  const prompt = createPrompt(
+    (_config: { message: string }, done: (value: string) => void) => {
+      useKeypress((key: KeypressEvent) => {
+        if (isEnterKey(key)) {
+          done('submitted');
+        }
+      });
+
+      return 'Question?';
+    },
+  );
+
+  // Use PassThrough which has proper stream buffering (like real process.stdin)
+  const input = new PassThrough();
+  const output = new PassThrough();
+  output.write = () => true; // suppress output
+
+  // Buffer an Enter keypress BEFORE the prompt exists
+  input.write('\r');
+
+  const answer = prompt({ message: 'test' }, { input, output });
+
+  // The buffered Enter should NOT resolve the prompt
+  const result = await Promise.race([
+    answer.then(() => 'resolved'),
+    new Promise((resolve) => setTimeout(() => resolve('pending'), 200)),
+  ]);
+  expect(result).toBe('pending');
+
+  // A real Enter AFTER creation should still work
+  input.write('\r');
+  await expect(answer).resolves.toBe('submitted');
+});
+
 it('fail on aborted signals', async () => {
   const Prompt = (config: { message: string }, done: (value: string) => void) => {
     useKeypress((key: KeypressEvent) => {

packages/core/src/lib/create-prompt.ts

@@ -9,6 +9,10 @@ import { type InquirerReadline } from '@inquirer/type';
 import { withHooks, effectScheduler } from './hook-engine.ts';
 import { AbortPromptError, CancelPromptError, ExitPromptError } from './errors.ts';
 
+// Capture the real setImmediate at module load time so it works even when test
+// frameworks mock timers with vi.useFakeTimers() or similar.
+const nativeSetImmediate = globalThis.setImmediate;
+
 type ViewFunction<Value, Config> = (
   config: Prettify<Config>,
   done: (value: Value) => void,
@@ -49,6 +53,11 @@ export function createPrompt<Value, Config>(
     const output = new MuteStream();
     output.pipe(context.output ?? process.stdout);
 
+    // Pre-mute the output so that readline doesn't echo stale keystrokes
+    // to the terminal before the first render. ScreenManager will unmute/mute
+    // the output around each render call as needed.
+    output.mute();
+
     const rl = readline.createInterface({
       terminal: true,
       input,
@@ -85,14 +94,6 @@ export function createPrompt<Value, Config>(
     rl.on('SIGINT', sigint);
     cleanups.add(() => rl.removeListener('SIGINT', sigint));
 
-    // Re-renders only happen when the state change; but the readline cursor could change position
-    // and that also requires a re-render (and a manual one because we mute the streams).
-    // We set the listener after the initial workLoop to avoid a double render if render triggered
-    // by a state change sets the cursor to the right position.
-    const checkCursorPos = () => screen.checkCursorPos();
-    rl.input.on('keypress', checkCursorPos);
-    cleanups.add(() => rl.input.removeListener('keypress', checkCursorPos));
-
     return withHooks(rl, (cycle) => {
       // The close event triggers immediately when the user press ctrl+c. SignalExit on the other hand
       // triggers after the process is done (which happens after timeouts are done triggering.)
@@ -101,30 +102,57 @@ export function createPrompt<Value, Config>(
       rl.on('close', hooksCleanup);
       cleanups.add(() => rl.removeListener('close', hooksCleanup));
 
-      cycle(() => {
-        try {
-          const nextView = view(config, (value) => {
-            setImmediate(() => resolve(value));
-          });
-
-          // Typescript won't allow this, but not all users rely on typescript.
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          if (nextView === undefined) {
-            const callerFilename = callSites[1]?.getFileName();
-            throw new Error(
-              `Prompt functions must return a string.\n    at ${callerFilename}`,
-            );
+      const startCycle = () => {
+        // Re-renders only happen when the state change; but the readline cursor could
+        // change position and that also requires a re-render (and a manual one because
+        // we mute the streams). We set the listener after the initial workLoop to avoid
+        // a double render if render triggered by a state change sets the cursor to the
+        // right position.
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on('keypress', checkCursorPos);
+        cleanups.add(() => rl.input.removeListener('keypress', checkCursorPos));
+
+        cycle(() => {
+          try {
+            const nextView = view(config, (value) => {
+              setImmediate(() => resolve(value));
+            });
+
+            // Typescript won't allow this, but not all users rely on typescript.
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (nextView === undefined) {
+              const callerFilename = callSites[1]?.getFileName();
+              throw new Error(
+                `Prompt functions must return a string.\n    at ${callerFilename}`,
+              );
+            }
+
+            const [content, bottomContent] =
+              typeof nextView === 'string' ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+
+            effectScheduler.run();
+          } catch (error: unknown) {
+            reject(error);
           }
-
-          const [content, bottomContent] =
-            typeof nextView === 'string' ? [nextView] : nextView;
-          screen.render(content, bottomContent);
-
-          effectScheduler.run();
-        } catch (error: unknown) {
-          reject(error);
-        }
-      });
+        });
+      };
+
+      // Proper Readable streams (like process.stdin) may have OS-level buffered
+      // data that arrives in the poll phase when readline resumes the stream.
+      // Deferring the first render by one setImmediate tick (check phase, after
+      // poll) lets that stale data flow through readline harmlessly—no keypress
+      // handlers are registered yet and the output is muted, so the stale
+      // keystrokes are silently discarded.
+      // Old-style streams (like MuteStream) have no such buffering, so the
+      // render cycle starts immediately.
+      //
+      // @see https://github.com/SBoudrias/Inquirer.js/issues/1303
+      if ('readableFlowing' in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
 
       return Object.assign(
         promise