@inquirer/testing 3.3.1 → 3.3.3

package/dist/buffered-stream.d.ts

@@ -0,0 +1,12 @@
+import { Stream } from 'node:stream';
+export declare class BufferedStream extends Stream.Writable {
+    #private;
+    columns: number;
+    get writeCount(): number;
+    _write(chunk: Buffer, _encoding: string, callback: () => void): void;
+    getLastChunk({ raw }?: {
+        raw?: boolean;
+    }): string;
+    getFullOutput(): string;
+    clear(): void;
+}

package/dist/buffered-stream.js

@@ -0,0 +1,43 @@
+import { Stream } from 'node:stream';
+import { stripVTControlCharacters } from 'node:util';
+export class BufferedStream extends Stream.Writable {
+    // Expose a large column width so cli-width (used by @inquirer/core's breakLines)
+    // doesn't hard-wrap output at 80 columns. This prevents artificial line breaks
+    // that would break assertions like toContain() in tests.
+    columns = 10_000;
+    #fullOutput = '';
+    #chunks = [];
+    #rawChunks = [];
+    #writeCount = 0;
+    get writeCount() {
+        return this.#writeCount;
+    }
+    _write(chunk, _encoding, callback) {
+        const str = chunk.toString();
+        this.#fullOutput += str;
+        // Keep track of every chunk sent through.
+        this.#rawChunks.push(str);
+        // Stripping the ANSI codes here because Inquirer will push commands ANSI (like cursor move.)
+        // This is probably fine since we don't care about those for testing; but this could become
+        // an issue if we ever want to test for those.
+        if (stripVTControlCharacters(str).trim().length > 0) {
+            this.#chunks.push(str);
+            this.#writeCount++;
+            this.emit('render');
+        }
+        callback();
+    }
+    getLastChunk({ raw } = {}) {
+        const chunks = raw ? this.#rawChunks : this.#chunks;
+        const lastChunk = chunks.at(-1);
+        return lastChunk ?? '';
+    }
+    getFullOutput() {
+        return this.#fullOutput;
+    }
+    clear() {
+        this.#fullOutput = '';
+        this.#chunks = [];
+        this.#rawChunks = [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import MuteStream from 'mute-stream';
+import type { Prompt, Context } from '@inquirer/type';
+type RenderOptions = Omit<Context, 'input' | 'output'>;
+export declare function render<Value, const Config>(prompt: Prompt<Value, Config>, config: Config, options?: RenderOptions): Promise<{
+    answer: Promise<Value>;
+    input: MuteStream;
+    events: {
+        keypress: (key: string | {
+            name?: string;
+            ctrl?: boolean;
+            meta?: boolean;
+            shift?: boolean;
+        }) => void;
+        type: (text: string) => void;
+    };
+    getScreen: ({ raw }?: {
+        raw?: boolean;
+    }) => string;
+    getFullOutput: ({ raw }?: {
+        raw?: boolean;
+    }) => Promise<string>;
+    nextRender: () => Promise<void>;
+}>;
+export {};

package/dist/index.js

@@ -0,0 +1,63 @@
+import { stripVTControlCharacters } from 'node:util';
+import MuteStream from 'mute-stream';
+import { BufferedStream } from "./buffered-stream.js";
+import { interpretTerminalOutput } from "./terminal.js";
+export async function render(prompt, config, options) {
+    const input = new MuteStream();
+    input.unmute();
+    const output = new BufferedStream();
+    const firstRender = new Promise((resolve) => output.once('render', resolve));
+    const answer = prompt(config, { ...options, input, output });
+    // The first render is synchronous. If our BufferedStream received a write, we're ready.
+    if (output.writeCount === 0) {
+        // Our BufferedStream didn't receive a write yet. This happens when the prompt
+        // errored before rendering. Race against the answer promise to handle that case.
+        await Promise.race([firstRender, answer.catch(() => { })]);
+    }
+    const events = {
+        keypress(key) {
+            if (typeof key === 'string') {
+                input.emit('keypress', null, { name: key });
+            }
+            else {
+                input.emit('keypress', null, key);
+            }
+        },
+        type(text) {
+            input.write(text);
+            for (const char of text) {
+                input.emit('keypress', null, { name: char });
+            }
+        },
+    };
+    let rendersConsumed = output.writeCount;
+    function nextRender() {
+        const waitForRender = output.writeCount > rendersConsumed
+            ? Promise.resolve()
+            : new Promise((resolve) => output.once('render', resolve));
+        // After detecting a render, let the event loop settle so that multiple
+        // synchronous-ish renders (e.g. validation: loading → error) are coalesced.
+        return waitForRender.then(() => new Promise((resolve) => {
+            setImmediate(() => {
+                rendersConsumed = output.writeCount;
+                resolve();
+            });
+        }));
+    }
+    return {
+        answer,
+        input,
+        events,
+        getScreen: ({ raw } = {}) => {
+            const lastScreen = output.getLastChunk({ raw: Boolean(raw) });
+            return raw ? lastScreen : stripVTControlCharacters(lastScreen).trim();
+        },
+        getFullOutput: async ({ raw } = {}) => {
+            const fullOutput = output.getFullOutput();
+            if (raw)
+                return fullOutput;
+            return interpretTerminalOutput(fullOutput);
+        },
+        nextRender,
+    };
+}

package/dist/jest.d.ts

@@ -0,0 +1,21 @@
+import type { Prompt } from '@inquirer/type';
+import { Screen } from './screen.ts';
+declare const screenInstance: Screen;
+export { screenInstance as screen };
+/**
+ * Wrap a prompt function to use the shared screen I/O.
+ * Use this in your own `jest.mock()` calls to mock third-party prompts.
+ *
+ * @example
+ * ```ts
+ * jest.mock('@my-company/custom-prompt', () => {
+ *   const { wrapPrompt } = jest.requireActual('@inquirer/testing/jest');
+ *   const actual = jest.requireActual('@my-company/custom-prompt');
+ *   return { ...actual, default: wrapPrompt(actual.default) };
+ * });
+ * ```
+ */
+export declare function wrapPrompt<Value, Config>(prompt: Prompt<Value, Config> | {
+    default: Prompt<Value, Config>;
+}): Prompt<Value, Config>;
+export { Screen, type KeypressEvent } from './screen.js';

package/dist/jest.js

@@ -0,0 +1,198 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+// Note: Jest's requireActual returns `any` by design, unlike Vitest's typed importOriginal
+import { Screen } from "./screen.js";
+// Global screen instance - exported for tests
+const screenInstance = new Screen();
+export { screenInstance as screen };
+// Reset before each test (Jest's beforeEach)
+beforeEach(() => {
+    screenInstance.clear();
+});
+/**
+ * Wrap a prompt function to use the shared screen I/O.
+ * Use this in your own `jest.mock()` calls to mock third-party prompts.
+ *
+ * @example
+ * ```ts
+ * jest.mock('@my-company/custom-prompt', () => {
+ *   const { wrapPrompt } = jest.requireActual('@inquirer/testing/jest');
+ *   const actual = jest.requireActual('@my-company/custom-prompt');
+ *   return { ...actual, default: wrapPrompt(actual.default) };
+ * });
+ * ```
+ */
+export function wrapPrompt(prompt) {
+    // Unwrap SWC-style module namespace objects where barrel re-exports like
+    // `export { default as input } from '@inquirer/input'` get transformed into
+    // `{ default: fn }` instead of the function directly.
+    const fn = typeof prompt === 'function' ? prompt : prompt.default;
+    return (config, context) => {
+        const output = screenInstance.createOutput();
+        const promise = fn(config, {
+            ...context,
+            input: screenInstance.input,
+            output,
+        });
+        screenInstance.setActivePromise(promise);
+        return promise;
+    };
+}
+// Prompt names used by the @inquirer/prompts barrel mock to wrap only prompt exports.
+const promptNames = [
+    'input',
+    'select',
+    'confirm',
+    'checkbox',
+    'password',
+    'expand',
+    'rawlist',
+    'number',
+    'search',
+    'editor',
+];
+// Mock individual prompt packages (covers `import input from '@inquirer/input'` style).
+// All prompt packages are optional peer dependencies, so factories silently skip
+// packages that aren't installed in the consumer's project.
+jest.mock('@inquirer/input', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/input');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/select', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/select');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/confirm', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/confirm');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/checkbox', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/checkbox');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/password', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/password');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/expand', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/expand');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/rawlist', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/rawlist');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/number', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/number');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/search', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/search');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+jest.mock('@inquirer/editor', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/editor');
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+// Mock @inquirer/prompts barrel re-exports (covers `import { input } from '@inquirer/prompts'` style).
+// Jest's module mock for individual packages doesn't propagate through barrel re-exports.
+// Only prompt functions are wrapped; other exports (like Separator) are passed through.
+jest.mock('@inquirer/prompts', () => {
+    try {
+        const actual = jest.requireActual('@inquirer/prompts');
+        const wrapped = { ...actual };
+        for (const name of promptNames) {
+            if (name in actual) {
+                wrapped[name] = wrapPrompt(actual[name]);
+            }
+        }
+        return wrapped;
+    }
+    catch {
+        return {};
+    }
+});
+// Mock the external editor to capture typed input instead of spawning a real editor.
+// Buffers all screen.type() calls and submits on screen.keypress('enter'), matching
+// the interaction pattern of other prompts (type → enter).
+jest.mock('@inquirer/external-editor', () => {
+    try {
+        jest.requireActual('@inquirer/external-editor');
+    }
+    catch {
+        return {};
+    }
+    return {
+        editAsync: (_text) => {
+            let buffer = '';
+            return new Promise((resolve) => {
+                const typeSpy = jest
+                    .spyOn(screenInstance, 'type')
+                    .mockImplementation((text) => {
+                    buffer += text;
+                });
+                const keypressSpy = jest
+                    .spyOn(screenInstance, 'keypress')
+                    .mockImplementation((key) => {
+                    const name = typeof key === 'string' ? key : key.name;
+                    if (name === 'enter' || name === 'return') {
+                        typeSpy.mockRestore();
+                        keypressSpy.mockRestore();
+                        resolve(buffer);
+                    }
+                });
+            });
+        },
+    };
+});
+// Re-export Screen class and KeypressEvent type for advanced use cases
+export { Screen } from './screen.js';

package/dist/screen.d.ts

@@ -0,0 +1,35 @@
+import MuteStream from 'mute-stream';
+import { BufferedStream } from './buffered-stream.ts';
+export type KeypressEvent = {
+    name?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+};
+export declare class Screen {
+    #private;
+    constructor();
+    get input(): MuteStream;
+    createOutput(): BufferedStream;
+    setActivePromise(promise: Promise<unknown>): void;
+    /**
+     * Wait for the next screen update.
+     *
+     * Handles re-renders within the same prompt (e.g., validation errors,
+     * async updates) and prompt transitions in multi-prompt flows
+     * (automatically waits for the next prompt).
+     *
+     * Note: The initial prompt render is available immediately via getScreen()
+     * — no next() call is needed before reading it.
+     */
+    next(): Promise<void>;
+    getScreen({ raw }?: {
+        raw?: boolean;
+    }): string;
+    getFullOutput({ raw }?: {
+        raw?: boolean;
+    }): Promise<string>;
+    keypress(key: string | KeypressEvent): void;
+    type(text: string): void;
+    clear(): void;
+}

package/dist/screen.js

@@ -0,0 +1,150 @@
+import { stripVTControlCharacters } from 'node:util';
+import MuteStream from 'mute-stream';
+import { BufferedStream } from "./buffered-stream.js";
+import { interpretTerminalOutput } from "./terminal.js";
+export class Screen {
+    #input;
+    #outputs = [];
+    #currentOutput = null;
+    #activePromise = null;
+    #rendersConsumed = 0;
+    #renderResolve = null;
+    constructor() {
+        this.#input = new MuteStream();
+        this.#input.unmute();
+    }
+    get input() {
+        return this.#input;
+    }
+    createOutput() {
+        const output = new BufferedStream();
+        this.#outputs.push(output);
+        this.#currentOutput = output;
+        this.#rendersConsumed = 0;
+        // Forward render events for cross-output listening
+        output.on('render', () => {
+            if (this.#renderResolve) {
+                this.#renderResolve();
+            }
+        });
+        return output;
+    }
+    setActivePromise(promise) {
+        this.#activePromise = promise;
+        // Auto-consume the initial render. Since createPrompt renders synchronously,
+        // getScreen() works immediately after starting a prompt — no next() needed.
+        this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
+    }
+    /**
+     * Wait for the next screen update.
+     *
+     * Handles re-renders within the same prompt (e.g., validation errors,
+     * async updates) and prompt transitions in multi-prompt flows
+     * (automatically waits for the next prompt).
+     *
+     * Note: The initial prompt render is available immediately via getScreen()
+     * — no next() call is needed before reading it.
+     */
+    async next() {
+        if (this.#activePromise) {
+            const currentPromise = this.#activePromise;
+            // Consume any renders that happened synchronously (e.g., loading state).
+            // We want to wait for the next meaningful state change, not an intermediate render.
+            this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
+            // Race: a future render (validation error, async update) vs the promise settling
+            // (prompt completed, possibly synchronously before any new render arrives).
+            const renderPromise = this.#waitForNextRender();
+            const settlePromise = currentPromise.then(() => 'settled', () => 'settled');
+            const result = await Promise.race([
+                renderPromise.then(() => 'render'),
+                settlePromise,
+            ]);
+            if (result === 'settled') {
+                if (this.#activePromise !== currentPromise) {
+                    // New prompt already started — its render was caught by the race's renderPromise.
+                    this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
+                }
+                else {
+                    // Prompt settled but no new prompt yet. Wait for the next prompt's first render.
+                    await this.#waitForNextRender();
+                }
+            }
+            else {
+                // Got a render. Check if the prompt also completed (making this a "done" render).
+                // Microtasks (promise settlement) always drain before macrotasks (setImmediate),
+                // so if the prompt resolved, its .then wins the race.
+                const settled = await Promise.race([
+                    currentPromise.then(() => true, () => true),
+                    new Promise((resolve) => setImmediate(() => resolve(false))),
+                ]);
+                if (settled) {
+                    if (this.#activePromise !== currentPromise) {
+                        // New prompt already started — its render was caught by the race.
+                        this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
+                    }
+                    else {
+                        // Prompt completed but no new prompt yet. Wait for it.
+                        await this.#waitForNextRender();
+                    }
+                }
+            }
+        }
+        else {
+            // No active promise — wait for a render (e.g., prompt hasn't started yet)
+            await this.#waitForNextRender();
+        }
+    }
+    async #waitForNextRender() {
+        const writeCount = this.#currentOutput?.writeCount ?? 0;
+        if (writeCount > this.#rendersConsumed) {
+            this.#rendersConsumed = writeCount;
+            return;
+        }
+        await new Promise((resolve) => {
+            const handler = () => {
+                this.#renderResolve = null;
+                resolve();
+            };
+            // Listen on current output (for re-renders within same prompt)
+            this.#currentOutput?.once('render', handler);
+            // Also set up cross-output listener (for prompt transitions and initial render)
+            this.#renderResolve = handler;
+        });
+        this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
+    }
+    getScreen({ raw } = {}) {
+        const lastScreen = this.#currentOutput?.getLastChunk({ raw: Boolean(raw) }) ?? '';
+        return raw ? lastScreen : stripVTControlCharacters(lastScreen).trim();
+    }
+    async getFullOutput({ raw } = {}) {
+        const output = this.#outputs.map((o) => o.getFullOutput()).join('');
+        if (raw)
+            return output;
+        return interpretTerminalOutput(output);
+    }
+    keypress(key) {
+        if (typeof key === 'string') {
+            this.#input.emit('keypress', null, { name: key });
+        }
+        else {
+            this.#input.emit('keypress', null, key);
+        }
+    }
+    type(text) {
+        this.#input.write(text);
+        for (const char of text) {
+            this.#input.emit('keypress', null, { name: char });
+        }
+    }
+    clear() {
+        // Recreate input stream to ensure clean state
+        this.#input = new MuteStream();
+        this.#input.unmute();
+        // Reset output tracking
+        this.#outputs = [];
+        this.#currentOutput = null;
+        this.#activePromise = null;
+        this.#rendersConsumed = 0;
+        this.#renderResolve = null;
+    }
+}

package/dist/terminal.d.ts

@@ -0,0 +1 @@
+export declare function interpretTerminalOutput(rawOutput: string, cols?: number, rows?: number): Promise<string>;

package/dist/terminal.js

@@ -0,0 +1,20 @@
+import xterm from '@xterm/headless';
+export async function interpretTerminalOutput(rawOutput, cols = 10_000, rows = 4000) {
+    const term = new xterm.Terminal({
+        cols,
+        rows,
+        allowProposedApi: true,
+        convertEol: true,
+    });
+    await new Promise((resolve) => term.write(rawOutput, resolve));
+    const lines = [];
+    for (let i = 0; i < term.rows; i++) {
+        lines.push(term.buffer.active.getLine(i)?.translateToString(true) ?? '');
+    }
+    term.dispose();
+    // Trim trailing empty lines
+    while (lines.length > 0 && lines.at(-1) === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}

package/dist/vitest.d.ts

@@ -0,0 +1,22 @@
+import type { Prompt } from '@inquirer/type';
+import { Screen } from './screen.ts';
+declare const screenInstance: Screen;
+export { screenInstance as screen };
+/**
+ * Wrap a prompt function to use the shared screen I/O.
+ * Use this in your own `vi.mock()` calls to mock third-party prompts.
+ *
+ * @example
+ * ```ts
+ * import { wrapPrompt } from '@inquirer/testing/vitest';
+ *
+ * vi.mock('@my-company/custom-prompt', async (importOriginal) => {
+ *   const actual = await importOriginal<typeof import('@my-company/custom-prompt')>();
+ *   return { ...actual, default: wrapPrompt(actual.default) };
+ * });
+ * ```
+ */
+export declare function wrapPrompt<Value, Config>(prompt: Prompt<Value, Config> | {
+    default: Prompt<Value, Config>;
+}): Prompt<Value, Config>;
+export { Screen, type KeypressEvent } from './screen.js';

package/dist/vitest.js

@@ -0,0 +1,192 @@
+import { vi, beforeEach } from 'vitest';
+import { Screen } from "./screen.js";
+// Global screen instance - exported for tests
+const screenInstance = new Screen();
+export { screenInstance as screen };
+// Reset before each test
+beforeEach(() => {
+    screenInstance.clear();
+});
+/**
+ * Wrap a prompt function to use the shared screen I/O.
+ * Use this in your own `vi.mock()` calls to mock third-party prompts.
+ *
+ * @example
+ * ```ts
+ * import { wrapPrompt } from '@inquirer/testing/vitest';
+ *
+ * vi.mock('@my-company/custom-prompt', async (importOriginal) => {
+ *   const actual = await importOriginal<typeof import('@my-company/custom-prompt')>();
+ *   return { ...actual, default: wrapPrompt(actual.default) };
+ * });
+ * ```
+ */
+export function wrapPrompt(prompt) {
+    // Unwrap SWC-style module namespace objects where barrel re-exports like
+    // `export { default as input } from '@inquirer/input'` get transformed into
+    // `{ default: fn }` instead of the function directly.
+    const fn = typeof prompt === 'function' ? prompt : prompt.default;
+    return (config, context) => {
+        const output = screenInstance.createOutput();
+        const promise = fn(config, {
+            ...context,
+            input: screenInstance.input,
+            output,
+        });
+        screenInstance.setActivePromise(promise);
+        return promise;
+    };
+}
+// Mock individual prompt packages (covers `import input from '@inquirer/input'` style).
+// All prompt packages are optional peer dependencies, so factories silently skip
+// packages that aren't installed in the consumer's project.
+vi.mock('@inquirer/input', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/select', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/confirm', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/checkbox', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/password', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/expand', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/rawlist', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/number', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/search', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+vi.mock('@inquirer/editor', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return { ...actual, default: wrapPrompt(actual.default) };
+    }
+    catch {
+        return {};
+    }
+});
+// Mock @inquirer/prompts barrel re-exports (covers `import { input } from '@inquirer/prompts'` style).
+// While Vitest's module interception often propagates through ESM re-exports, an explicit mock
+// ensures consistent behavior across all environments and bundler configurations.
+// Only prompt functions are wrapped; other exports (like Separator) are passed through.
+vi.mock('@inquirer/prompts', async (importOriginal) => {
+    try {
+        const actual = await importOriginal();
+        return {
+            ...actual,
+            input: wrapPrompt(actual.input),
+            select: wrapPrompt(actual.select),
+            confirm: wrapPrompt(actual.confirm),
+            checkbox: wrapPrompt(actual.checkbox),
+            password: wrapPrompt(actual.password),
+            expand: wrapPrompt(actual.expand),
+            rawlist: wrapPrompt(actual.rawlist),
+            number: wrapPrompt(actual.number),
+            search: wrapPrompt(actual.search),
+            editor: wrapPrompt(actual.editor),
+        };
+    }
+    catch {
+        return {};
+    }
+});
+// Mock the external editor to capture typed input instead of spawning a real editor.
+// Buffers all screen.type() calls and submits on screen.keypress('enter'), matching
+// the interaction pattern of other prompts (type → enter).
+vi.mock('@inquirer/external-editor', async (importOriginal) => {
+    try {
+        await importOriginal();
+    }
+    catch {
+        return {};
+    }
+    return {
+        editAsync: (_text) => {
+            let buffer = '';
+            return new Promise((resolve) => {
+                const typeSpy = vi
+                    .spyOn(screenInstance, 'type')
+                    .mockImplementation((text) => {
+                    buffer += text;
+                });
+                const keypressSpy = vi
+                    .spyOn(screenInstance, 'keypress')
+                    .mockImplementation((key) => {
+                    const name = typeof key === 'string' ? key : key.name;
+                    if (name === 'enter' || name === 'return') {
+                        typeSpy.mockRestore();
+                        keypressSpy.mockRestore();
+                        resolve(buffer);
+                    }
+                });
+            });
+        },
+    };
+});
+// Re-export Screen class and KeypressEvent type for advanced use cases
+export { Screen } from './screen.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inquirer/testing",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "Inquirer testing utilities",
   "keywords": [
     "answer",
@@ -83,16 +83,16 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/type": "^4.0.3",
+    "@inquirer/type": "^4.0.5",
     "@xterm/headless": "^6.0.0",
     "mute-stream": "^3.0.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/mute-stream": "^0.0.4",
-    "@types/node": "^25.0.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "peerDependencies": {
     "@inquirer/checkbox": ">=1.0.0",
@@ -167,5 +167,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "1ce03199b82b4a5fb6f7c97ce374c6da5087444f"
+  "gitHead": "e68fe01d65359e083581c48c4a18cd8f97d88842"
 }