@fyeeme/pi-ask-user 2.0.0 → 2.0.1

package/src/ask-legacy.ts

@@ -0,0 +1,642 @@
+/**
+ * Legacy per-question ask path — migrated from oh-my-pi
+ * (packages/coding-agent/src/tools/ask.ts, askSingleQuestion and its
+ * custom-input title helpers).
+ *
+ * This path serves hosts without rich dialog support (RPC mode). Questions are
+ * asked one at a time through native select/input dialogs, mirroring omp's
+ * legacy selector flow: recommended suffixes, a multi-select toggle loop with
+ * a "Done selecting" terminal option, "Other" free-text via the editor, the
+ * timeout auto-selection with the TIMEOUT_DETECTION_TOLERANCE heuristic, and
+ * (i/n) progress titles.
+ *
+ * Adaptations for pi's extension API:
+ * - pi's ui.select accepts only `{ signal, timeout }` dialog options. The omp
+ *   options (initialIndex, onTimeout*, onLeft/onRight, helpText,
+ *   selectionMarker, checkedIndices, markableCount, outline) are still part
+ *   of UIContext and still honored by selectOption()'s bookkeeping, but the
+ *   pi adapter layer cannot forward them, so surfaces render without radio/
+ *   checkbox markers, initial cursor placement, and ←/→ question navigation.
+ *   The logic is kept 1:1 so hosts that do support the options (tests, future
+ *   pi) light them up automatically.
+ * - Option descriptions cannot ride along in pi's string[] select; they are
+ *   dropped from the visible list (labels stay).
+ * - omp's ui.editor(title, prefill, {signal}, {promptStyle}) maps to pi's
+ *   ui.editor(title, prefill) (multi-line, no signal) with a fallback to
+ *   ui.input on hosts without an editor; the signal race moves to a local
+ *   untilAborted equivalent.
+ * - omp's untilAborted / AbortSignal.any utilities are re-implemented locally.
+ */
+
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { ELLIPSIS, replaceTabs, SYMBOLS } from "./compat.ts";
+import type { AskOption, ExtensionUISelectItem } from "./types.ts";
+
+export type { AskOption };
+
+function getSelectOptionLabel(option: ExtensionUISelectItem): string {
+	return typeof option === "string" ? option : option.label;
+}
+
+function getSelectOptionDescription(option: ExtensionUISelectItem): string | undefined {
+	return typeof option === "string" ? undefined : option.description;
+}
+
+function toSelectOption(option: AskOption, label = option.label): ExtensionUISelectItem {
+	return option.description ? { label, description: option.description } : label;
+}
+
+export const RECOMMENDED_SUFFIX = " (Recommended)";
+export const OTHER_OPTION = "Other (type your own)";
+const CHAT_ABOUT_THIS_OPTION = "Chat about this";
+export const NEXT_OPTION = "Next →";
+/** Reserved runtime labels the model must not collide with (omp ask.ts). */
+export const RESERVED_OPTION_LABELS: Record<string, true> = {
+	[OTHER_OPTION]: true,
+	[CHAT_ABOUT_THIS_OPTION]: true,
+	[NEXT_OPTION]: true,
+};
+// Window after the timeout deadline within which an `undefined` selection is
+// attributed to a UI-enforced timeout (for surfaces that close the dialog at
+// the deadline but never invoke `onTimeout`). Cancels beyond it are user Esc.
+const TIMEOUT_DETECTION_TOLERANCE_MS = 1_000;
+
+function getDoneOptionLabel(): string {
+	return `${SYMBOLS.status.success} Done selecting`;
+}
+
+/** Add "(Recommended)" suffix to the option at the given index if not already present */
+export function addRecommendedSuffix(options: AskOption[], recommendedIndex?: number): ExtensionUISelectItem[] {
+	if (recommendedIndex === undefined || recommendedIndex < 0 || recommendedIndex >= options.length) {
+		return options.map(option => toSelectOption(option));
+	}
+	return options.map((option, i) => {
+		const label =
+			i === recommendedIndex && !option.label.endsWith(RECOMMENDED_SUFFIX)
+				? option.label + RECOMMENDED_SUFFIX
+				: option.label;
+		return toSelectOption(option, label);
+	});
+}
+
+export function getAutoSelectionOnTimeout(options: AskOption[], recommended?: number): string[] {
+	if (options.length === 0) return [];
+	if (typeof recommended === "number" && recommended >= 0 && recommended < options.length) {
+		return [options[recommended]!.label];
+	}
+	return [options[0]!.label];
+}
+
+/** Strip "(Recommended)" suffix from a label */
+export function stripRecommendedSuffix(label: string): string {
+	return label.endsWith(RECOMMENDED_SUFFIX) ? label.slice(0, -RECOMMENDED_SUFFIX.length) : label;
+}
+
+// --- untilAborted / signal composition (omp @oh-my-pi/pi-utils) ------------
+
+function composeSignals(a: AbortSignal | undefined, b: AbortSignal | undefined): AbortSignal | undefined {
+	if (!a) return b;
+	if (!b) return a;
+	if (a.aborted || b.aborted) return AbortSignal.abort();
+	const controller = new AbortController();
+	const onAbort = (): void => controller.abort();
+	a.addEventListener("abort", onAbort, { once: true });
+	b.addEventListener("abort", onAbort, { once: true });
+	return controller.signal;
+}
+
+/** omp utils untilAborted: resolve `undefined` when the signal fires first,
+ *  otherwise pass the wrapped promise's outcome through untouched. */
+function untilAborted<T>(signal: AbortSignal | undefined, run: () => Promise<T>): Promise<T | undefined> {
+	if (!signal) return run();
+	if (signal.aborted) return Promise.resolve(undefined);
+	return new Promise<T | undefined>((resolve, reject) => {
+		let settled = false;
+		const settleAbort = (): void => {
+			if (settled) return;
+			settled = true;
+			resolve(undefined);
+		};
+		signal.addEventListener("abort", settleAbort, { once: true });
+		run().then(
+			value => {
+				if (settled) return;
+				settled = true;
+				signal.removeEventListener("abort", settleAbort);
+				resolve(value);
+			},
+			error => {
+				if (settled) return;
+				settled = true;
+				signal.removeEventListener("abort", settleAbort);
+				reject(error);
+			},
+		);
+	});
+}
+
+// --- custom input title (omp buildCustomInputRows & friends) ----------------
+
+interface CustomInputContext {
+	selectionMarker: "radio" | "checkbox";
+	checkedIndices?: readonly number[];
+	markableCount: number;
+}
+
+const MAX_CUSTOM_INPUT_OPTION_ROWS = 8;
+const MAX_CUSTOM_INPUT_TITLE_ROWS = 16;
+const MIN_CUSTOM_INPUT_CONTENT_WIDTH = 20;
+const CUSTOM_INPUT_CHROME_COLUMNS = 8;
+const CUSTOM_INPUT_DESCRIPTION_INDENT = "    ";
+
+function customInputContentWidth(): number {
+	const cols = process.stdout.columns ?? 80;
+	return Math.max(MIN_CUSTOM_INPUT_CONTENT_WIDTH, cols - CUSTOM_INPUT_CHROME_COLUMNS);
+}
+
+function clampLineToWidth(line: string, width: number): string {
+	if (visibleWidth(line) <= width) return line;
+	return truncateToWidth(line, width, ELLIPSIS);
+}
+
+function flattenDescription(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+interface CustomInputOptionGap {
+	total: number;
+	checked: number;
+}
+
+interface CustomInputOptionWindow {
+	indices: number[];
+	gapBefore: Map<number, CustomInputOptionGap>;
+}
+
+/** Window the option list so the title stays bounded (omp pickCustomInputOptionWindow). */
+function pickCustomInputOptionWindow(
+	total: number,
+	selectedIndex: number,
+	checked: ReadonlySet<number>,
+): CustomInputOptionWindow {
+	if (total === 0) return { indices: [], gapBefore: new Map() };
+	if (total <= MAX_CUSTOM_INPUT_OPTION_ROWS) {
+		return {
+			indices: Array.from({ length: total }, (_, i) => i),
+			gapBefore: new Map(),
+		};
+	}
+	const keep = new Set<number>();
+	const addIfRoom = (index: number) => {
+		if (index >= 0 && index < total && keep.size < MAX_CUSTOM_INPUT_OPTION_ROWS) {
+			keep.add(index);
+		}
+	};
+	addIfRoom(selectedIndex);
+	addIfRoom(0);
+	for (const i of [...checked].sort((a, b) => a - b)) {
+		addIfRoom(i);
+	}
+	for (let i = 0; i < total && keep.size < MAX_CUSTOM_INPUT_OPTION_ROWS; i++) {
+		addIfRoom(i);
+	}
+	const indices = [...keep].sort((a, b) => a - b);
+	const gapBefore = new Map<number, CustomInputOptionGap>();
+	const countCheckedBetween = (startInclusive: number, endExclusive: number): number => {
+		let count = 0;
+		for (const i of checked) {
+			if (i >= startInclusive && i < endExclusive) count++;
+		}
+		return count;
+	};
+	let prev = -1;
+	for (const idx of indices) {
+		if (idx > prev + 1) {
+			gapBefore.set(idx, {
+				total: idx - prev - 1,
+				checked: countCheckedBetween(prev + 1, idx),
+			});
+		}
+		prev = idx;
+	}
+	if (prev < total - 1) {
+		gapBefore.set(total, {
+			total: total - 1 - prev,
+			checked: countCheckedBetween(prev + 1, total),
+		});
+	}
+	return { indices, gapBefore };
+}
+
+interface CustomInputRow {
+	text: string;
+	priority: number;
+}
+
+function buildCustomInputRows(
+	question: string,
+	options: ExtensionUISelectItem[],
+	context: CustomInputContext,
+	contentWidth: number,
+): CustomInputRow[] {
+	const selectedIndex = options.findIndex(option => getSelectOptionLabel(option) === OTHER_OPTION);
+	const checked = new Set(context.checkedIndices ?? []);
+	const window = pickCustomInputOptionWindow(options.length, selectedIndex, checked);
+	const rows: CustomInputRow[] = [];
+	rows.push({ text: clampLineToWidth(question, contentWidth), priority: -1 });
+	rows.push({ text: "", priority: -1 });
+
+	const emitGap = (gap: CustomInputOptionGap) => {
+		const checkedSuffix = gap.checked > 0 ? `, ${gap.checked} checked` : "";
+		rows.push({
+			text: clampLineToWidth(
+				`    … ${gap.total} more option${gap.total === 1 ? "" : "s"}${checkedSuffix} …`,
+				contentWidth,
+			),
+			priority: 2,
+		});
+	};
+
+	for (const index of window.indices) {
+		const gap = window.gapBefore.get(index);
+		if (gap !== undefined) emitGap(gap);
+		const option = options[index]!;
+		const label = getSelectOptionLabel(option);
+		const isSelected = index === selectedIndex;
+		const isMarkable = index < context.markableCount;
+		const prefix =
+			context.selectionMarker === "radio" && (isMarkable || isSelected)
+				? `${isSelected ? SYMBOLS.radio.selected : SYMBOLS.radio.unselected} `
+				: context.selectionMarker === "checkbox" && isMarkable
+					? `${checked.has(index) ? SYMBOLS.checkbox.checked : SYMBOLS.checkbox.unchecked} `
+					: isSelected
+						? `${SYMBOLS.nav.cursor} `
+						: "  ";
+		rows.push({ text: clampLineToWidth(prefix + label, contentWidth), priority: -1 });
+		const description = getSelectOptionDescription(option);
+		if (description) {
+			const flat = flattenDescription(description);
+			if (flat) {
+				rows.push({
+					text: clampLineToWidth(`${CUSTOM_INPUT_DESCRIPTION_INDENT}${flat}`, contentWidth),
+					priority: isSelected ? 2 : checked.has(index) ? 1 : 0,
+				});
+			}
+		}
+	}
+
+	const trailingGap = window.gapBefore.get(options.length);
+	if (trailingGap !== undefined) emitGap(trailingGap);
+	rows.push({ text: "", priority: -1 });
+	rows.push({ text: "Enter your response:", priority: -1 });
+	return rows;
+}
+
+function applyCustomInputRowBudget(rows: CustomInputRow[], budget: number): CustomInputRow[] {
+	if (rows.length <= budget) return rows;
+	const droppable = rows
+		.map((row, index) => ({ row, index }))
+		.filter(entry => entry.row.priority >= 0)
+		.sort((a, b) => a.row.priority - b.row.priority || b.index - a.index);
+	const removed = new Set<number>();
+	for (const { index } of droppable) {
+		if (rows.length - removed.size <= budget) break;
+		removed.add(index);
+	}
+	return rows.filter((_, i) => !removed.has(i));
+}
+
+export function formatCustomInputTitle(
+	question: string,
+	options: ExtensionUISelectItem[],
+	context: CustomInputContext,
+): string {
+	const contentWidth = customInputContentWidth();
+	const rows = buildCustomInputRows(question, options, context, contentWidth);
+	return applyCustomInputRowBudget(rows, MAX_CUSTOM_INPUT_TITLE_ROWS)
+		.map(row => row.text)
+		.join("\n");
+}
+
+// --- askSingleQuestion (omp ask.ts) ----------------------------------------
+
+export interface SelectionResult {
+	selectedOptions: string[];
+	customInput?: string;
+	timedOut: boolean;
+	navigation?: "back" | "forward";
+	cancelled?: boolean;
+}
+
+export interface NavigationControls {
+	allowBack: boolean;
+	allowForward: boolean;
+	progressText?: string;
+}
+
+export interface AskSingleQuestionOptions {
+	recommended?: number;
+	timeout?: number;
+	signal?: AbortSignal;
+	initialSelection?: Pick<SelectionResult, "selectedOptions" | "customInput">;
+	navigation?: NavigationControls;
+}
+
+export interface UIContext {
+	timeoutStartsOnPresentation?: boolean;
+	select(
+		prompt: string,
+		options: ExtensionUISelectItem[],
+		options_?: {
+			initialIndex?: number;
+			timeout?: number;
+			signal?: AbortSignal;
+			outline?: boolean;
+			onTimeout?: () => void;
+			onTimeoutStart?: () => void;
+			onTimeoutReset?: () => void;
+			onLeft?: () => void;
+			onRight?: () => void;
+			helpText?: string;
+			selectionMarker?: "radio" | "checkbox";
+			checkedIndices?: readonly number[];
+			markableCount?: number;
+		},
+	): Promise<string | undefined>;
+	editor(title: string, prefill?: string, dialogOptions?: { signal?: AbortSignal }): Promise<string | undefined>;
+}
+
+/** Adapt pi's ExtensionUIContext to the omp UIContext surface. */
+export function uiContextFromExtension(extensionUi: Pick<ExtensionUIContext, "select" | "input" | "editor">): UIContext {
+	return {
+		select: (prompt, options, dialogOptions) =>
+			extensionUi.select(
+				prompt,
+				options.map(option => getSelectOptionLabel(option)),
+				{
+					...(dialogOptions?.timeout !== undefined ? { timeout: dialogOptions.timeout } : {}),
+					...(dialogOptions?.signal !== undefined ? { signal: dialogOptions.signal } : {}),
+				},
+			),
+		editor: (title, prefill, dialogOptions) => {
+			const show = () => extensionUi.editor(title, prefill);
+			const input = () => extensionUi.input(title, prefill);
+			// Prefer pi's multi-line editor; fall back to input when absent.
+			const run = () => (typeof extensionUi.editor === "function" ? show() : input());
+			return dialogOptions?.signal ? untilAborted(dialogOptions.signal, run) : run();
+		},
+	};
+}
+
+export async function askSingleQuestion(
+	ui: UIContext,
+	question: string,
+	questionOptions: AskOption[],
+	multi: boolean,
+	options: AskSingleQuestionOptions = {},
+): Promise<SelectionResult> {
+	const { recommended, timeout, signal, initialSelection, navigation } = options;
+	const doneLabel = getDoneOptionLabel();
+	let selectedOptions = [...(initialSelection?.selectedOptions ?? [])];
+	let customInput = initialSelection?.customInput;
+	let timedOut = false;
+
+	const selectOption = async (
+		prompt: string,
+		optionsToShow: ExtensionUISelectItem[],
+		initialIndex?: number,
+		marker?: { selectionMarker: "radio" | "checkbox"; checkedIndices?: readonly number[]; markableCount: number },
+	): Promise<{ choice: string | undefined; timedOut: boolean; navigation?: "back" | "forward" }> => {
+		let timeoutTriggered = false;
+		const onTimeout = () => {
+			timeoutTriggered = true;
+		};
+		let navigationAction: "back" | "forward" | undefined;
+		const timeoutMs = typeof timeout === "number" && timeout > 0 ? timeout : undefined;
+		const timeoutController = timeoutMs === undefined ? undefined : new AbortController();
+		const dialogSignal = composeSignals(signal, timeoutController?.signal);
+		let timeoutId: ReturnType<typeof setTimeout> | undefined;
+		let timeoutStartedMs = Date.now();
+		const armFallbackTimeout = (durationMs: number) => {
+			clearTimeout(timeoutId);
+			timeoutStartedMs = Date.now();
+			timeoutId = setTimeout(() => {
+				timeoutTriggered = true;
+				timeoutController?.abort();
+			}, durationMs);
+		};
+		const helpText = navigation
+			? "up/down navigate  enter select  ←/→ question  esc cancel"
+			: "up/down navigate  enter select  esc cancel";
+		const dialogOptions = {
+			initialIndex,
+			timeout,
+			signal: dialogSignal,
+			outline: true,
+			helpText,
+			onTimeout,
+			onTimeoutStart: timeoutMs === undefined ? undefined : () => armFallbackTimeout(timeoutMs),
+			onTimeoutReset: timeoutMs === undefined ? undefined : () => armFallbackTimeout(timeoutMs),
+			selectionMarker: marker?.selectionMarker,
+			checkedIndices: marker?.checkedIndices,
+			markableCount: marker?.markableCount,
+			onLeft: navigation?.allowBack
+				? () => {
+						navigationAction = "back";
+					}
+				: undefined,
+			onRight: navigation?.allowForward
+				? () => {
+						navigationAction = "forward";
+					}
+				: undefined,
+		};
+		try {
+			const runSelect = () => {
+				const selection = ui.select(prompt, optionsToShow, dialogOptions);
+				if (timeoutMs !== undefined && !ui.timeoutStartsOnPresentation) {
+					armFallbackTimeout(timeoutMs);
+				}
+				return selection;
+			};
+			const choice = await (dialogSignal ? untilAborted(dialogSignal, runSelect) : runSelect());
+			if (!timeoutTriggered && choice === undefined && typeof timeout === "number") {
+				// Fallback for UI surfaces that enforce `timeout` without invoking
+				// `onTimeout`: their auto-cancel resolves right at the deadline. A
+				// cancel arriving well past the deadline is a deliberate user Esc on
+				// a surface that kept the dialog open — keep treating it as a cancel.
+				const elapsed = Date.now() - timeoutStartedMs;
+				timeoutTriggered = elapsed >= timeout && elapsed <= timeout + TIMEOUT_DETECTION_TOLERANCE_MS;
+			}
+			return { choice, timedOut: timeoutTriggered, navigation: navigationAction };
+		} catch (error) {
+			if (timeoutTriggered && error instanceof Error && error.name === "AbortError") {
+				return { choice: undefined, timedOut: true, navigation: navigationAction };
+			}
+			throw error;
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	};
+
+	const promptForCustomInput = async (
+		title: string,
+		optionsToShow: ExtensionUISelectItem[],
+		context: CustomInputContext,
+	): Promise<{ input: string | undefined }> => {
+		const dialogOptions = signal ? { signal } : undefined;
+		const editorTitle = formatCustomInputTitle(title, optionsToShow, context);
+		const showCustomInput = () => ui.editor(editorTitle, undefined, dialogOptions);
+		const input = signal ? await untilAborted(signal, showCustomInput) : await showCustomInput();
+		return { input };
+	};
+
+	const promptWithProgress = navigation?.progressText ? `${question} (${navigation.progressText})` : question;
+	if (multi) {
+		const selected = new Set<string>(selectedOptions);
+		let cursorIndex = Math.min(Math.max(recommended ?? 0, 0), Math.max(questionOptions.length - 1, 0));
+		const firstSelected = selectedOptions[0];
+		if (firstSelected) {
+			const selectedIndex = questionOptions.findIndex(option => option.label === firstSelected);
+			if (selectedIndex >= 0) cursorIndex = selectedIndex;
+		}
+		while (true) {
+			const opts: ExtensionUISelectItem[] = questionOptions.map(opt => toSelectOption(opt));
+
+			if (!navigation?.allowForward && selected.size > 0) {
+				opts.push(doneLabel);
+			}
+			opts.push(OTHER_OPTION);
+
+			const checkedIndices: number[] = [];
+			for (let i = 0; i < questionOptions.length; i++) {
+				if (selected.has(questionOptions[i]!.label)) checkedIndices.push(i);
+			}
+			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
+			const {
+				choice,
+				timedOut: selectTimedOut,
+				navigation: arrowNavigation,
+			} = await selectOption(`${prefix}${promptWithProgress}`, opts, cursorIndex, {
+				selectionMarker: "checkbox",
+				checkedIndices,
+				markableCount: questionOptions.length,
+			});
+
+			if (arrowNavigation) {
+				return { selectedOptions: Array.from(selected), customInput, timedOut, navigation: arrowNavigation };
+			}
+			if (choice === undefined) {
+				if (selectTimedOut) {
+					timedOut = true;
+					break;
+				}
+				return { selectedOptions: Array.from(selected), customInput, timedOut, cancelled: true };
+			}
+			if (choice === doneLabel) break;
+
+			if (choice === OTHER_OPTION) {
+				if (selectTimedOut) {
+					timedOut = true;
+					break;
+				}
+				const customResult = await promptForCustomInput(`${prefix}${promptWithProgress}`, opts, {
+					selectionMarker: "checkbox",
+					checkedIndices,
+					markableCount: questionOptions.length,
+				});
+				if (customResult.input === undefined) {
+					continue;
+				}
+				customInput = customResult.input;
+				break;
+			}
+
+			const selectedIdx = opts.findIndex(opt => getSelectOptionLabel(opt) === choice);
+			if (selectedIdx >= 0) {
+				cursorIndex = selectedIdx;
+			}
+
+			if (selected.has(choice)) {
+				selected.delete(choice);
+			} else {
+				selected.add(choice);
+			}
+
+			if (selectTimedOut) {
+				timedOut = true;
+				break;
+			}
+		}
+		selectedOptions = Array.from(selected);
+	} else {
+		while (true) {
+			const displayOptions = addRecommendedSuffix(questionOptions, recommended);
+			const optionsWithNavigation: ExtensionUISelectItem[] = [...displayOptions, OTHER_OPTION];
+
+			let initialIndex = recommended;
+			const previouslySelected = selectedOptions[0];
+			if (previouslySelected) {
+				const selectedIndex = questionOptions.findIndex(option => option.label === previouslySelected);
+				if (selectedIndex >= 0) initialIndex = selectedIndex;
+			} else if (customInput !== undefined) {
+				initialIndex = displayOptions.length;
+			}
+			if (initialIndex !== undefined) {
+				const maxIndex = Math.max(optionsWithNavigation.length - 1, 0);
+				initialIndex = Math.max(0, Math.min(initialIndex, maxIndex));
+			}
+
+			const {
+				choice,
+				timedOut: selectTimedOut,
+				navigation: arrowNavigation,
+			} = await selectOption(promptWithProgress, optionsWithNavigation, initialIndex, {
+				selectionMarker: "radio",
+				markableCount: displayOptions.length,
+			});
+			timedOut = selectTimedOut;
+
+			if (arrowNavigation) {
+				return { selectedOptions, customInput, timedOut, navigation: arrowNavigation };
+			}
+			if (choice === undefined) {
+				if (!timedOut) {
+					return { selectedOptions, customInput, timedOut, cancelled: true };
+				}
+				break;
+			}
+			if (choice === OTHER_OPTION) {
+				if (selectTimedOut) {
+					break;
+				}
+				const customResult = await promptForCustomInput(promptWithProgress, optionsWithNavigation, {
+					selectionMarker: "radio",
+					markableCount: displayOptions.length,
+				});
+				if (customResult.input === undefined) {
+					continue;
+				}
+				customInput = customResult.input;
+				selectedOptions = [];
+				break;
+			}
+			selectedOptions = [stripRecommendedSuffix(choice)];
+			customInput = undefined;
+			break;
+		}
+		if (timedOut && selectedOptions.length === 0 && customInput === undefined) {
+			selectedOptions = getAutoSelectionOnTimeout(questionOptions, recommended);
+		}
+		if (navigation?.allowForward) {
+			return { selectedOptions, customInput, timedOut, navigation: "forward" };
+		}
+	}
+
+	if (timedOut && selectedOptions.length === 0 && customInput === undefined) {
+		selectedOptions = getAutoSelectionOnTimeout(questionOptions, recommended);
+	}
+
+	return { selectedOptions, customInput, timedOut };
+}