hacksh 0.17.0 → 0.18.0

package/README.md

@@ -528,7 +528,7 @@ finishes. A printer failure rejects the invocation without changing a successful
 
 ### Interactive input
 
-Every `run` context has a `prompt` with `select`, `confirm`, and `text` methods. Interactive input
+Every `run` context has a `prompt` with `select`, `autocomplete`, `confirm`, and `text` methods. Interactive input
 is separate from `logger`: prompts share the invocation's selected printer, serialized output queue,
 terminal lock, output mode, and abort signal.
 
@@ -562,15 +562,57 @@ uses `initialValue` when supplied and otherwise means no. Text displays its plac
 using it as input, supports editing, and repeats the prompt only when `validate` returns a nonempty
 message; `""` means valid. Backspace removes one Unicode code point. Input pasted after a selection
 or confirmation is retained for the next sequential prompt instead of being discarded.
-The built-in prompt API intentionally stops at select, confirm, and text; it does not provide a
-multiselect prompt.
+The built-in prompt API does not provide a multiselect prompt.
+
+Use `autocomplete` for a searchable single choice:
+
+```ts
+const environment = await prompt.autocomplete({
+  message: "Environment",
+  placeholder: "Type to filter…",
+  options: [
+    { value: "production", label: "Production", priority: 20 },
+    { value: "staging", label: "Staging", hint: "safe default", priority: 10 },
+  ],
+  sortBy: (item) => item.priority,
+}); // "production" | "staging"; displays Staging before Production
+```
+
+Autocomplete filters labels (falling back to values) by case-insensitive substring,
+preserving the configured option order rather than ranking matches. An empty query
+shows all options, initially with none selected. Down enters selection at the first
+match; Up/Down move without wrapping. Up at the first match or Escape returns to
+editing. Typing or Backspace while selecting edits the query and returns to input.
+Enter submits only a selected match; it does nothing while editing or with no matches.
+Backspace removes one grapheme cluster. Escape while editing and Ctrl-C cancel.
+The placeholder is display-only, reappears when the query becomes empty, and remains
+until the terminal delivers committed input; OS IME composition is not observable.
+The pretty printer anchors the real cursor at the input end, including wrapped input.
+
+Both `select` and `autocomplete` accept `sortBy: (item) => string | number`. The
+callback receives the complete inferred option item, including custom fields such
+as `priority`; the prompt still returns only its `value`, preserving literal types.
+Without `sortBy`, options retain their definition order. With it, keys are computed
+once per option at prompt startup and sorted ascending, stably: equal keys retain
+definition order, and the original array is never reordered. Autocomplete filtering
+preserves this sorted order without recomputing keys. `initialValue` on select
+chooses a value in the sorted list without changing that order.
+
+Numeric keys use numeric order; strings use locale-independent UTF-16 lexical
+order, not locale-aware collation or numeric-string ordering. All keys in one
+prompt must have the same type. Invalid keys (including `NaN`) or mixed types
+produce `HackshPromptError` with reason `invalid-options`; a thrown callback
+produces `input-error` with the original error as `cause`.
+Explicit option types take the whole item type, for example
+`SelectOptions<{ value: "staging" | "production"; priority: number }>`.
 
 Prompts are allowed only when the resolved mode is interactive: pretty output outside CI with TTY
 stdin and stdout. JSON, CI, and non-TTY invocations throw `HackshPromptError` immediately even if a
 default is available. Its `reason` and `prompt` fields identify why input failed and the prompt's
-`kind`, `message`, and select `choices`. Reasons distinguish `non-interactive`, `cancelled`,
+`kind`, `message`, and select/autocomplete `choices`. Reasons distinguish `non-interactive`, `cancelled`,
 `aborted`, `eof`, `overlapping`, `invalid-options`, `input-error`, and `printer-error`. Ctrl-C and
-Escape cancel; `runMain` reports cancellation and exits with status 130. A prompt that starts or is
+Escape cancel (except Escape from autocomplete selection, which returns to editing);
+`runMain` reports cancellation and exits with status 130. A prompt that starts or is
 waiting after the invocation's `signal` aborts fails with `aborted` and the signal's reason as its
 `cause`. Only one prompt may be active in an invocation. Input listeners and raw terminal mode are
 restored after every outcome.
@@ -878,6 +920,17 @@ await showUsage(main, {
 | `vp run ready`         | Run check, test, and build                            |
 | `pnpm test:packed`     | Test the tarball with Node 22.18, host Node, and Deno |
 
+The autocomplete API has PTY tests in `src/autocomplete-pty.test.ts`.
+Run them with `pnpm test run src/autocomplete-pty.test.ts`. They launch
+`src/fixtures/autocomplete-pty-cli.ts`, a CLI using the public `prompt.autocomplete`
+API, and interpret its output with a headless terminal, checking visible choices,
+placeholder transitions, cursor coordinates, and submission/cancellation cleanup.
+For manual terminal verification, run `node src/fixtures/autocomplete-pty-cli.ts`.
+Expected screens use indented multiline strings; ANSI handling stays in
+`src/test-support/terminal.ts`. OS IME composition windows are outside this suite.
+The development-only `node-pty` dependency requires Python and a C/C++ build
+toolchain (Xcode Command Line Tools on macOS).
+
 The packed-consumer test must execute its Node consumer with exactly Node 22.18.0. Run pnpm itself
 under that version, or supply an absolute executable path explicitly:
 

package/dist/{command-t16M3-AZ.d.ts → command-Czf4qXhe.d.ts}

@@ -91,7 +91,7 @@ declare class HackshValidationError extends HackshUsageError {
   readonly issues: ReadonlyArray<HackshIssue>;
   constructor(command: AnyCommandDef, issues: ReadonlyArray<HackshIssue>);
 }
-type PromptKind = "select" | "confirm" | "text";
+type PromptKind = "select" | "autocomplete" | "confirm" | "text";
 type HackshPromptErrorReason = "non-interactive" | "cancelled" | "aborted" | "eof" | "overlapping" | "invalid-options" | "input-error" | "printer-error";
 interface PromptErrorDetails {
   kind: PromptKind;
@@ -277,7 +277,15 @@ interface TextPromptState extends PromptStateBase {
   value: string;
   placeholder?: string;
 }
-type PromptState = SelectPromptState | ConfirmPromptState | TextPromptState;
+interface AutocompletePromptState extends PromptStateBase {
+  kind: "autocomplete";
+  query: string;
+  placeholder?: string;
+  phase: "input" | "select";
+  choices: readonly PromptChoiceState[];
+  value?: string;
+}
+type PromptState = SelectPromptState | ConfirmPromptState | TextPromptState | AutocompletePromptState;
 interface PromptPrintEvent {
   type: "prompt";
   prompt: PromptState;
@@ -352,10 +360,16 @@ interface SelectOption<T extends string> {
   label?: string;
   hint?: string;
 }
-interface SelectOptions<T extends string> {
+interface ChoiceOptions<TItem extends SelectOption<string>> {
   message: string;
-  options: readonly SelectOption<T>[];
-  initialValue?: T;
+  options: readonly TItem[];
+  sortBy?: (item: NoInfer<TItem>) => string | number;
+}
+interface SelectOptions<TItem extends SelectOption<string>> extends ChoiceOptions<TItem> {
+  initialValue?: NoInfer<TItem["value"]>;
+}
+interface AutocompleteOptions<TItem extends SelectOption<string>> extends ChoiceOptions<TItem> {
+  placeholder?: string;
 }
 interface ConfirmOptions {
   message: string;
@@ -367,7 +381,8 @@ interface TextOptions {
   validate?(value: string): string | undefined;
 }
 interface Prompter {
-  select<const T extends string>(options: SelectOptions<T>): Promise<T>;
+  select<const TItem extends SelectOption<string>>(options: SelectOptions<TItem>): Promise<TItem["value"]>;
+  autocomplete<const TItem extends SelectOption<string>>(options: AutocompleteOptions<TItem>): Promise<TItem["value"]>;
   confirm(options: ConfirmOptions): Promise<boolean>;
   text(options: TextOptions): Promise<string>;
 }
@@ -416,5 +431,5 @@ interface CommandDef<S extends ArgsSchema = EmptyArgs, R = unknown, Children ext
 type AnyCommandDef = CommandDef<ArgsSchema>;
 declare function defineCommand<S extends ArgsSchema = EmptyArgs, R = never, Children extends Record<string, AnyCommandDef> = {}>(def: CommandDef<S, R, Children>): NoInfer<CommandDef<S, R, Children>>;
 //#endregion
-export { HackshErrorKind as $, SelectPromptState as A, UsageArgumentSummary as B, PrintStream as C, PromptState as D, PromptPrintEvent as E, UsagePrintEvent as F, showUsage as G, UsageOptionSummary as H, VersionPrintEvent as I, LogLevel as J, summarizeUsage as K, createJsonPrinter as L, TerminalInput as M, TerminalOutput as N, PromptStatus as O, TextPromptState as P, HackshError as Q, resolveOutputMode as R, PrintEvent as S, PromptChoiceState as T, UsageSummary as U, UsageCommandSummary as V, renderUsage as W, LogRecord as X, LogProperties as Y, Logger as Z, OutputFormat as _, ExecReturn as _t, ArgsSchema as a, HackshPromptErrorReason as at, OutputPrintEvent as b, SelectOption as c, PromptErrorDetails as ct, Output as d, Exec as dt, HackshErrorSummary as et, ConfirmPromptState as f, ExecCommand as ft, LogPrintEvent as g, ExecResult as gt, JsonPrinterOptions as h, ExecOptions as ht, defineCommand as i, HackshPromptError as it, StreamColors as j, ResolveOutputModeOptions as k, SelectOptions as l, PromptKind as lt, ExecPrintEvent as m, ExecFailureReason as mt, CommandContext as n, HackshExitError as nt, ConfirmOptions as o, HackshUsageError as ot, ErrorPrintEvent as p, ExecFailure as pt, LogKind as q, CommandDef as r, HackshIssue as rt, Prompter as s, HackshValidationError as st, AnyCommandDef as t, HackshExecError as tt, TextOptions as u, ValidationIssueSummary as ut, OutputMode as v, ExecSkipped as vt, Printer as w, OutputWriter as x, OutputPreference as y, ExecSuccess as yt, ShowUsageOptions as z };
-//# sourceMappingURL=command-t16M3-AZ.d.ts.map
+export { Logger as $, PromptStatus as A, resolveOutputMode as B, OutputWriter as C, PromptChoiceState as D, Printer as E, TerminalOutput as F, UsageSummary as G, UsageArgumentSummary as H, TextPromptState as I, summarizeUsage as J, renderUsage as K, UsagePrintEvent as L, SelectPromptState as M, StreamColors as N, PromptPrintEvent as O, TerminalInput as P, LogRecord as Q, VersionPrintEvent as R, OutputPrintEvent as S, PrintStream as T, UsageCommandSummary as U, ShowUsageOptions as V, UsageOptionSummary as W, LogLevel as X, LogKind as Y, LogProperties as Z, JsonPrinterOptions as _, ExecOptions as _t, ArgsSchema as a, HackshIssue as at, OutputMode as b, ExecSkipped as bt, Prompter as c, HackshUsageError as ct, TextOptions as d, PromptKind as dt, HackshError as et, Output as f, ValidationIssueSummary as ft, ExecPrintEvent as g, ExecFailureReason as gt, ErrorPrintEvent as h, ExecFailure as ht, defineCommand as i, HackshExitError as it, ResolveOutputModeOptions as j, PromptState as k, SelectOption as l, HackshValidationError as lt, ConfirmPromptState as m, ExecCommand as mt, CommandContext as n, HackshErrorSummary as nt, AutocompleteOptions as o, HackshPromptError as ot, AutocompletePromptState as p, Exec as pt, showUsage as q, CommandDef as r, HackshExecError as rt, ConfirmOptions as s, HackshPromptErrorReason as st, AnyCommandDef as t, HackshErrorKind as tt, SelectOptions as u, PromptErrorDetails as ut, LogPrintEvent as v, ExecResult as vt, PrintEvent as w, OutputPreference as x, ExecSuccess as xt, OutputFormat as y, ExecReturn as yt, createJsonPrinter as z };
+//# sourceMappingURL=command-Czf4qXhe.d.ts.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { G as showUsage, K as summarizeUsage, M as TerminalInput, N as TerminalOutput, Q as HackshError, W as renderUsage, Z as Logger, _t as ExecReturn, a as ArgsSchema, at as HackshPromptErrorReason, c as SelectOption, ct as PromptErrorDetails, d as Output, dt as Exec, ft as ExecCommand, gt as ExecResult, ht as ExecOptions, i as defineCommand, it as HackshPromptError, l as SelectOptions, lt as PromptKind, mt as ExecFailureReason, n as CommandContext, nt as HackshExitError, o as ConfirmOptions, ot as HackshUsageError, pt as ExecFailure, r as CommandDef, rt as HackshIssue, s as Prompter, st as HackshValidationError, t as AnyCommandDef, tt as HackshExecError, u as TextOptions, vt as ExecSkipped, w as Printer, y as OutputPreference, yt as ExecSuccess, z as ShowUsageOptions } from "./command-t16M3-AZ.js";
+import { $ as Logger, E as Printer, F as TerminalOutput, J as summarizeUsage, K as renderUsage, P as TerminalInput, V as ShowUsageOptions, _t as ExecOptions, a as ArgsSchema, at as HackshIssue, bt as ExecSkipped, c as Prompter, ct as HackshUsageError, d as TextOptions, dt as PromptKind, et as HackshError, f as Output, gt as ExecFailureReason, ht as ExecFailure, i as defineCommand, it as HackshExitError, l as SelectOption, lt as HackshValidationError, mt as ExecCommand, n as CommandContext, o as AutocompleteOptions, ot as HackshPromptError, pt as Exec, q as showUsage, r as CommandDef, rt as HackshExecError, s as ConfirmOptions, st as HackshPromptErrorReason, t as AnyCommandDef, u as SelectOptions, ut as PromptErrorDetails, vt as ExecResult, x as OutputPreference, xt as ExecSuccess, yt as ExecReturn } from "./command-Czf4qXhe.js";
 import { output } from "zod/v4/core";
 //#region src/parser.d.ts
 /**
@@ -39,5 +39,5 @@ interface RunMainOptions extends OutputOptions {
 }
 declare function runMain<S extends ArgsSchema>(command: CommandDef<S>, options?: RunMainOptions): Promise<void>;
 //#endregion
-export { type CommandContext, type CommandDef, type ConfirmOptions, type Exec, type ExecCommand, type ExecFailure, type ExecFailureReason, type ExecOptions, type ExecResult, type ExecReturn, type ExecSkipped, type ExecSuccess, HackshError, HackshExecError, HackshExitError, type HackshIssue, HackshPromptError, type HackshPromptErrorReason, HackshUsageError, HackshValidationError, type Logger, type Output, type OutputOptions, type PromptErrorDetails, type PromptKind, type Prompter, type RunCommandOptions, type RunMainOptions, type SelectOption, type SelectOptions, type ShowUsageOptions, type TextOptions, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage, summarizeUsage };
+export { type AutocompleteOptions, type CommandContext, type CommandDef, type ConfirmOptions, type Exec, type ExecCommand, type ExecFailure, type ExecFailureReason, type ExecOptions, type ExecResult, type ExecReturn, type ExecSkipped, type ExecSuccess, HackshError, HackshExecError, HackshExitError, type HackshIssue, HackshPromptError, type HackshPromptErrorReason, HackshUsageError, HackshValidationError, type Logger, type Output, type OutputOptions, type PromptErrorDetails, type PromptKind, type Prompter, type RunCommandOptions, type RunMainOptions, type SelectOption, type SelectOptions, type ShowUsageOptions, type TextOptions, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage, summarizeUsage };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as createExec, c as HackshExitError, d as HackshValidationError, f as summarizeError, i as resolveOutputMode, l as HackshPromptError, n as createJsonPrinter, o as HackshError, p as summarizeErrors, r as createPrintQueue, s as HackshExecError, t as createPrettyPrinter, u as HackshUsageError } from "./pretty-Db7-kATM.js";
+import { a as createExec, c as HackshExitError, d as HackshValidationError, f as summarizeError, i as resolveOutputMode, l as HackshPromptError, n as createJsonPrinter, o as HackshError, p as summarizeErrors, r as createPrintQueue, s as HackshExecError, t as createPrettyPrinter, u as HackshUsageError } from "./pretty-BjzGnVLM.js";
 import { globalRegistry, safeParseAsync } from "zod/v4/core";
 import { parseArgs as parseArgs$1 } from "node:util";
 import { readFile, realpath } from "node:fs/promises";
@@ -619,6 +619,44 @@ function promptError(reason, prompt, message, cause) {
 function validateMessage(kind, message, choices) {
 	if (typeof message !== "string" || message.length === 0) throw promptError("invalid-options", details$1(kind, message, choices), `Invalid ${kind} prompt: message must be a non-empty string`);
 }
+function validateChoices(kind, options) {
+	const choices = Array.isArray(options?.options) ? options.options.map((option) => typeof option === "object" && option !== null && typeof option.value === "string" ? option.value : "[Invalid choice]") : [];
+	const prompt = details$1(kind, options?.message, choices);
+	validateMessage(kind, options?.message, choices);
+	if (!Array.isArray(options.options) || options.options.length === 0) throw promptError("invalid-options", prompt, `A ${kind} prompt requires at least one choice`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const option of options.options) {
+		if (typeof option !== "object" || option === null || typeof option.value !== "string" || option.value.length === 0 || option.label !== void 0 && typeof option.label !== "string" || option.hint !== void 0 && typeof option.hint !== "string") throw promptError("invalid-options", prompt, `${kind === "select" ? "Select" : "Autocomplete"} choices must have valid string values`);
+		if (seen.has(option.value)) throw promptError("invalid-options", prompt, `Duplicate ${kind} choice: ${option.value}`);
+		seen.add(option.value);
+	}
+	return prompt;
+}
+function sortedChoices(options, prompt) {
+	const { sortBy } = options;
+	if (sortBy === void 0) return options.options;
+	if (typeof sortBy !== "function") throw promptError("invalid-options", prompt, "sortBy must be a function");
+	let keyType;
+	const keyed = options.options.map((item) => {
+		let key;
+		try {
+			key = sortBy(item);
+		} catch (cause) {
+			throw promptError("input-error", prompt, "Choice sort key could not be computed", cause);
+		}
+		if (typeof key !== "string" && (typeof key !== "number" || Number.isNaN(key))) throw promptError("invalid-options", prompt, "sortBy must return a string or a non-NaN number");
+		const type = typeof key;
+		if (keyType !== void 0 && keyType !== type) throw promptError("invalid-options", prompt, "sortBy keys must all have the same type");
+		keyType = type;
+		return {
+			item,
+			key
+		};
+	});
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	return keyed.map(({ item }) => item);
+}
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function asInput(value, prompt) {
 	if (typeof value !== "object" || value === null || typeof Reflect.get(value, "on") !== "function" || typeof Reflect.get(value, "removeListener") !== "function" || typeof Reflect.get(value, "resume") !== "function" || typeof Reflect.get(value, "pause") !== "function") throw promptError("input-error", prompt, "Interactive input is not a readable stream");
 	return value;
@@ -647,7 +685,7 @@ var PromptController = class {
 			throw promptError("printer-error", prompt, "The prompt could not be displayed", cause);
 		}
 	}
-	async #run(prompt, initial, accept, update, submitted, closed) {
+	async #run(prompt, initial, accept, update, submitted, closed, cancelOnEscape = () => true) {
 		if (!this.#interactive) throw promptError("non-interactive", prompt, `Cannot request ${prompt.kind} input in non-interactive mode: ${prompt.message}`);
 		if (this.#signal.aborted) throw promptError("aborted", prompt, "Prompt aborted", this.#signal.reason);
 		const input = asInput(this.#inputValue, prompt);
@@ -689,7 +727,7 @@ var PromptController = class {
 					};
 					const handleKeypress = async (character, key = {}) => {
 						if (settled) return;
-						if (key.ctrl && key.name === "c" || key.name === "escape") {
+						if (key.ctrl && key.name === "c" || key.name === "escape" && cancelOnEscape()) {
 							fail("cancelled", "Prompt cancelled");
 							return;
 						}
@@ -797,36 +835,71 @@ var PromptController = class {
 		}
 	}
 	async select(options) {
-		const choices = Array.isArray(options?.options) ? options.options.map((option) => typeof option === "object" && option !== null && typeof option.value === "string" ? option.value : "[Invalid choice]") : [];
-		const prompt = details$1("select", options?.message, choices);
-		validateMessage("select", options?.message, choices);
-		if (!Array.isArray(options.options) || options.options.length === 0) throw promptError("invalid-options", prompt, "A select prompt requires at least one choice");
-		const seen = /* @__PURE__ */ new Set();
-		for (const option of options.options) {
-			if (typeof option !== "object" || option === null || typeof option.value !== "string" || option.value.length === 0 || option.label !== void 0 && typeof option.label !== "string" || option.hint !== void 0 && typeof option.hint !== "string") throw promptError("invalid-options", prompt, "Select choices must have valid string values");
-			if (seen.has(option.value)) throw promptError("invalid-options", prompt, `Duplicate select choice: ${option.value}`);
-			seen.add(option.value);
-		}
-		let selected = options.initialValue === void 0 ? 0 : choices.indexOf(options.initialValue);
+		const prompt = validateChoices("select", options);
+		const choices = sortedChoices(options, prompt);
+		let selected = options.initialValue === void 0 ? 0 : choices.findIndex(({ value }) => value === options.initialValue);
 		if (selected < 0) throw promptError("invalid-options", prompt, `Unknown initial select value: ${String(options.initialValue)}`);
 		const state = (status = "active") => ({
 			kind: "select",
 			message: options.message,
 			status,
-			value: options.options[selected].value,
-			choices: options.options.map(({ value, label, hint }, index) => ({
+			value: choices[selected].value,
+			choices: choices.map(({ value, label, hint }, index) => ({
 				value,
 				label: label ?? value,
 				...hint === void 0 ? {} : { hint },
 				selected: index === selected
 			}))
 		});
-		return await this.#run(prompt, state(), (_character, key) => key.name === "return" || key.name === "enter" ? options.options[selected].value : void 0, (_character, key) => {
+		return await this.#run(prompt, state(), (_character, key) => key.name === "return" || key.name === "enter" ? choices[selected].value : void 0, (_character, key) => {
 			if (key.name !== "up" && key.name !== "down") return void 0;
-			selected = (selected + (key.name === "up" ? -1 : 1) + options.options.length) % options.options.length;
+			selected = (selected + (key.name === "up" ? -1 : 1) + choices.length) % choices.length;
 			return state();
 		}, () => state("submitted"), () => state("closed"));
 	}
+	async autocomplete(options) {
+		const prompt = validateChoices("autocomplete", options);
+		if (options.placeholder !== void 0 && typeof options.placeholder !== "string") throw promptError("invalid-options", prompt, "Autocomplete placeholder must be a string");
+		const choices = sortedChoices(options, prompt);
+		let query = "";
+		let selected = -1;
+		let filtered = choices;
+		const state = (status = "active") => ({
+			kind: "autocomplete",
+			message: options.message,
+			status,
+			query,
+			phase: selected < 0 ? "input" : "select",
+			...options.placeholder === void 0 ? {} : { placeholder: options.placeholder },
+			...selected < 0 ? {} : { value: filtered[selected].value },
+			choices: filtered.map(({ value, label, hint }, index) => ({
+				value,
+				label: label ?? value,
+				...hint === void 0 ? {} : { hint },
+				selected: index === selected
+			}))
+		});
+		return await this.#run(prompt, state(), (_character, key) => selected >= 0 && (key.name === "return" || key.name === "enter") ? filtered[selected].value : void 0, (character, key) => {
+			if (key.name === "down") {
+				if (selected >= filtered.length - 1) return void 0;
+				selected += 1;
+			} else if (key.name === "up") {
+				if (selected < 0) return void 0;
+				selected -= 1;
+			} else if (key.name === "escape") selected = -1;
+			else {
+				if (key.name === "backspace") {
+					const last = graphemeSegmenter.segment(query).containing(query.length - 1);
+					query = last === void 0 ? "" : query.slice(0, last.index);
+				} else if (!key.ctrl && !key.meta && character.length > 0 && !/\p{Cc}/u.test(character)) query += character;
+				else return void 0;
+				selected = -1;
+				const search = query.toLowerCase();
+				filtered = search.length === 0 ? choices : choices.filter(({ value, label }) => (label ?? value).toLowerCase().includes(search));
+			}
+			return state();
+		}, () => state("submitted"), () => state("closed"), () => selected < 0);
+	}
 	async confirm(options) {
 		const prompt = details$1("confirm", options?.message);
 		validateMessage("confirm", options?.message);