@ryan_nookpi/pi-extension-ask-user-question 0.1.0 → 0.2.0

package/README.md

@@ -1,15 +1,43 @@
 # @ryan_nookpi/pi-extension-ask-user-question
 
-Independent pi package for the `AskUserQuestion` extension.
+Interactive multi-question form tool for pi.
+
+After installation, pi can use the `ask_user_question` tool to collect structured input from the user with:
+
+- `radio` questions for single choice
+- `checkbox` questions for multiple choice
+- `text` questions for free-form answers
+- optional `Other...` inputs for custom answers
 
 ## Install
 
 ```bash
-pi install /Users/creatrip/Documents/pi-extension/packages/ask-user-question
 pi install npm:@ryan_nookpi/pi-extension-ask-user-question
 ```
 
-## What it provides
+## Example
 
-- `AskUserQuestion` tool
-- `./index.ts` entry
+```json
+{
+  "title": "Deployment settings",
+  "description": "Need a few decisions before continuing.",
+  "questions": [
+    {
+      "id": "env",
+      "type": "radio",
+      "prompt": "Which environment should I use?",
+      "options": [
+        { "value": "staging", "label": "Staging" },
+        { "value": "prod", "label": "Production" }
+      ]
+    },
+    {
+      "id": "notes",
+      "type": "text",
+      "prompt": "Anything else I should know?",
+      "required": false,
+      "placeholder": "Optional notes"
+    }
+  ]
+}
+```

package/constants.ts

@@ -0,0 +1,10 @@
+export const SYM = {
+	radioOn: "◉",
+	radioOff: "○",
+	checkOn: "☑",
+	checkOff: "☐",
+	pointer: "❯",
+	dot: "·",
+	check: "✓",
+	submit: "✓",
+} as const;

package/controller.test.ts

@@ -0,0 +1,281 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createFormController } from "./controller.ts";
+import { createAnswerState, normalizeQuestions } from "./state.ts";
+import type { EditorAdapter, FormResult, RenderTheme } from "./types.ts";
+
+class FakeEditor implements EditorAdapter {
+	text = "";
+	onSubmit?: (value: string) => void;
+	handledInputs: string[] = [];
+
+	getText(): string {
+		return this.text;
+	}
+
+	setText(text: string): void {
+		this.text = text;
+	}
+
+	handleInput(data: string): void {
+		this.handledInputs.push(data);
+		if (data.length === 1 && data !== "\t") {
+			this.text += data;
+		}
+	}
+
+	render(): string[] {
+		return this.text ? [this.text] : [];
+	}
+}
+
+const theme: RenderTheme = {
+	fg: (_color, text) => text,
+	bg: (_color, text) => `[${text}]`,
+	bold: (text) => text,
+};
+
+function createController(questionInput: Parameters<typeof normalizeQuestions>[0]) {
+	const questions = normalizeQuestions(questionInput);
+	const answerState = createAnswerState(questions);
+	const editor = new FakeEditor();
+	const requestRender = vi.fn();
+	const done = vi.fn<(result: FormResult) => void>();
+	const controller = createFormController({
+		title: "Title",
+		description: "Description",
+		questions,
+		answerState,
+		editor,
+		theme,
+		requestRender,
+		done,
+	});
+	return { controller, questions, answerState, editor, requestRender, done };
+}
+
+describe("ask-user-question/controller", () => {
+	it("renders with caching and supports empty question sets", () => {
+		const empty = createController([]);
+		const firstRender = empty.controller.render(40);
+		const secondRender = empty.controller.render(40);
+		expect(firstRender).toBe(secondRender);
+		empty.controller.invalidate();
+		expect(empty.controller.render(40)).not.toBe(firstRender);
+		empty.controller.handleInput("x");
+		expect(empty.done).not.toHaveBeenCalled();
+	});
+
+	it("handles text questions, submission, cancellation, and editor fallback submit", () => {
+		const first = createController([{ id: "text", type: "text", prompt: "Explain", default: "seed" }]);
+		expect(first.editor.getText()).toBe("seed");
+
+		first.controller.handleInput("!");
+		first.controller.handleInput("\r");
+		expect(first.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: first.questions,
+			answers: [{ id: "text", type: "text", value: "seed!", wasCustom: true }],
+			cancelled: false,
+		});
+		expect(first.requestRender).toHaveBeenCalled();
+
+		const cancelled = createController([{ id: "text", type: "text", prompt: "Explain" }]);
+		cancelled.controller.handleInput("\u001b");
+		expect(cancelled.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: cancelled.questions,
+			answers: [{ id: "text", type: "text", value: "", wasCustom: true }],
+			cancelled: true,
+		});
+
+		const fallback = createController([{ id: "text", type: "text", prompt: "Explain" }]);
+		fallback.editor.onSubmit?.("  from submit  ");
+		expect(fallback.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: fallback.questions,
+			answers: [{ id: "text", type: "text", value: "from submit", wasCustom: true }],
+			cancelled: false,
+		});
+	});
+
+	it("handles radio other-mode editing, tab navigation, and cancellation", () => {
+		const setup = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		setup.answerState.radioAnswers.set("radio", { value: "saved", label: "saved", wasCustom: true });
+
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput("\u001b[A");
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput("\r");
+		expect(setup.controller.getState()).toMatchObject({ otherMode: true, otherQuestionId: "radio" });
+		expect(setup.editor.getText()).toBe("saved");
+		expect(setup.controller.render(80).join("\n")).toContain("Your answer:");
+
+		setup.controller.handleInput("x");
+		setup.controller.handleInput("\t");
+		expect(setup.answerState.radioAnswers.get("radio")).toEqual({ value: "savedx", label: "savedx", wasCustom: true });
+		expect(setup.controller.getState()).toMatchObject({ currentTab: 1, otherMode: false });
+
+		setup.controller.handleInput("\u001b[Z");
+		expect(setup.controller.getState().currentTab).toBe(0);
+		setup.controller.handleInput("\u001b");
+		expect(setup.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: setup.questions,
+			answers: [
+				{ id: "radio", type: "radio", value: "savedx", wasCustom: true },
+				{ id: "text", type: "text", value: "", wasCustom: true },
+			],
+			cancelled: true,
+		});
+	});
+
+	it("supports radio selection, checkbox toggles, other-mode enter, and successful submit", () => {
+		const setup = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [{ value: "b", label: "Beta" }] },
+		]);
+
+		setup.controller.handleInput("\r");
+		expect(setup.controller.getState().currentTab).toBe(1);
+		expect(setup.answerState.radioAnswers.get("radio")).toEqual({ value: "a", label: "Alpha", wasCustom: false });
+
+		setup.controller.handleInput(" ");
+		expect(setup.answerState.checkAnswers.get("check")).toEqual(new Set(["b"]));
+		setup.controller.handleInput(" ");
+		expect(setup.answerState.checkAnswers.get("check")).toEqual(new Set());
+
+		setup.controller.handleInput("\u001b[B");
+		setup.controller.handleInput(" ");
+		expect(setup.controller.getState().otherMode).toBe(true);
+		setup.editor.setText("custom");
+		setup.controller.handleInput("\r");
+		expect(setup.answerState.checkCustom.get("check")).toBe("custom");
+		expect(setup.controller.getState().currentTab).toBe(2);
+
+		setup.controller.handleInput("\r");
+		expect(setup.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: setup.questions,
+			answers: [
+				{ id: "radio", type: "radio", value: "a", wasCustom: false },
+				{ id: "check", type: "checkbox", value: ["custom"], wasCustom: true },
+			],
+			cancelled: false,
+		});
+	});
+
+	it("handles onSubmit custom input, no-option branches, submit-tab navigation, and other-mode escape", () => {
+		const submitOther = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		submitOther.controller.handleInput("\u001b[B");
+		submitOther.controller.handleInput("\r");
+		submitOther.editor.onSubmit?.("typed");
+		expect(submitOther.answerState.radioAnswers.get("radio")).toEqual({
+			value: "typed",
+			label: "typed",
+			wasCustom: true,
+		});
+		expect(submitOther.controller.getState().currentTab).toBe(1);
+
+		const nonTextSubmit = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+		]);
+		nonTextSubmit.editor.onSubmit?.("ignored");
+		expect(nonTextSubmit.done).not.toHaveBeenCalled();
+
+		const shiftOther = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		shiftOther.controller.handleInput("\u001b[B");
+		shiftOther.controller.handleInput("\r");
+		shiftOther.editor.setText("back");
+		shiftOther.controller.handleInput("\u001b[Z");
+		expect(shiftOther.answerState.radioAnswers.get("radio")).toEqual({ value: "back", label: "back", wasCustom: true });
+		expect(shiftOther.controller.getState().currentTab).toBe(2);
+
+		const noOptions = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [], allowOther: false },
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [], allowOther: false },
+		]);
+		noOptions.controller.handleInput("\r");
+		expect(noOptions.done).not.toHaveBeenCalled();
+		noOptions.controller.handleInput("\u001b[C");
+		noOptions.controller.handleInput("\u001b[D");
+		expect(noOptions.controller.getState().currentTab).toBe(0);
+		noOptions.controller.handleInput("\u001b[C");
+		noOptions.controller.handleInput(" ");
+		noOptions.controller.handleInput("\r");
+		expect(noOptions.controller.getState().currentTab).toBe(2);
+
+		const deletedSet = createController([
+			{ id: "check", type: "checkbox", prompt: "Pick many", options: [{ value: "b", label: "Beta" }] },
+		]);
+		deletedSet.answerState.checkAnswers.delete("check");
+		deletedSet.controller.handleInput(" ");
+		expect(deletedSet.answerState.checkAnswers.get("check")).toEqual(new Set(["b"]));
+		deletedSet.controller.handleInput("x");
+		expect(deletedSet.done).not.toHaveBeenCalled();
+
+		const checkboxSingle = createController([{ id: "check", type: "checkbox", prompt: "Pick many", options: [] }]);
+		checkboxSingle.controller.handleInput("\r");
+		expect(checkboxSingle.done).toHaveBeenCalledWith({
+			title: "Title",
+			questions: checkboxSingle.questions,
+			answers: [{ id: "check", type: "checkbox", value: [], wasCustom: false }],
+			cancelled: false,
+		});
+
+		const blocked = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+			{ id: "text", type: "text", prompt: "Explain" },
+		]);
+		blocked.controller.handleInput("\u001b[C");
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(2);
+		blocked.controller.handleInput("\r");
+		expect(blocked.done).not.toHaveBeenCalled();
+		blocked.controller.handleInput("\u001b[D");
+		expect(blocked.controller.getState().currentTab).toBe(1);
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(2);
+		blocked.controller.handleInput("\t");
+		expect(blocked.controller.getState().currentTab).toBe(0);
+		blocked.controller.handleInput("\u001b");
+		expect(blocked.done).toHaveBeenCalled();
+
+		const submitCancel = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }], default: "a" },
+			{ id: "text", type: "text", prompt: "Explain", default: "done" },
+		]);
+		submitCancel.controller.handleInput("\u001b[C");
+		submitCancel.controller.handleInput("\t");
+		submitCancel.controller.handleInput("\u001b");
+		expect(submitCancel.done).toHaveBeenCalled();
+
+		const submitNav = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }], default: "a" },
+			{ id: "text", type: "text", prompt: "Explain", default: "done" },
+		]);
+		submitNav.controller.handleInput("\u001b[C");
+		submitNav.controller.handleInput("\t");
+		expect(submitNav.controller.getState().currentTab).toBe(2);
+		submitNav.controller.handleInput("\u001b[C");
+		expect(submitNav.controller.getState().currentTab).toBe(0);
+
+		const otherEscape = createController([
+			{ id: "radio", type: "radio", prompt: "Pick one", options: [{ value: "a", label: "Alpha" }] },
+		]);
+		otherEscape.controller.handleInput("\u001b[B");
+		otherEscape.controller.handleInput("\r");
+		otherEscape.controller.handleInput("\u001b");
+		expect(otherEscape.controller.getState()).toMatchObject({ otherMode: false, otherQuestionId: null });
+		expect(otherEscape.editor.getText()).toBe("");
+	});
+});

package/controller.ts

@@ -0,0 +1,280 @@
+import { Key, matchesKey } from "@mariozechner/pi-tui";
+
+import { allRequiredAnswered, buildAnswers, optionCount, saveOtherAnswer, saveTextAnswer } from "./state.ts";
+import type { AnswerState, EditorAdapter, FormResult, NormalizedQuestion, RenderTheme } from "./types.ts";
+import { renderForm } from "./view.ts";
+
+export interface FormController {
+	render(width: number): string[];
+	invalidate(): void;
+	handleInput(data: string): void;
+	getState(): {
+		currentTab: number;
+		cursorIdx: number;
+		otherMode: boolean;
+		otherQuestionId: string | null;
+	};
+}
+
+interface CreateFormControllerInput {
+	title?: string;
+	description?: string;
+	questions: NormalizedQuestion[];
+	answerState: AnswerState;
+	editor: EditorAdapter;
+	theme: RenderTheme;
+	requestRender(): void;
+	done(result: FormResult): void;
+}
+
+export function createFormController(input: CreateFormControllerInput): FormController {
+	const { questions, answerState, editor, theme } = input;
+	const isMulti = questions.length > 1;
+	const totalTabs = questions.length + (isMulti ? 1 : 0);
+
+	let currentTab = 0;
+	let cursorIdx = 0;
+	let otherMode = false;
+	let otherQuestionId: string | null = null;
+	let cachedLines: string[] | undefined;
+
+	function getCurrentQuestion(): NormalizedQuestion | undefined {
+		return questions[currentTab];
+	}
+
+	function refresh(): void {
+		cachedLines = undefined;
+		input.requestRender();
+	}
+
+	function saveCurrentTextQuestion(): void {
+		const question = getCurrentQuestion();
+		if (question?.type !== "text") return;
+		saveTextAnswer(answerState, question.id, editor.getText());
+	}
+
+	function saveOtherModeText(questionId: string): void {
+		saveOtherAnswer(answerState, questions, questionId, editor.getText());
+		otherMode = false;
+		otherQuestionId = null;
+		editor.setText("");
+	}
+
+	function switchTab(nextTab: number): void {
+		saveCurrentTextQuestion();
+		currentTab = ((nextTab % totalTabs) + totalTabs) % totalTabs;
+		cursorIdx = 0;
+		otherMode = false;
+		otherQuestionId = null;
+		const question = getCurrentQuestion();
+		if (question?.type === "text") {
+			editor.setText(answerState.textAnswers.get(question.id) ?? "");
+		}
+		refresh();
+	}
+
+	function finish(cancelled: boolean): void {
+		saveCurrentTextQuestion();
+		input.done({
+			title: input.title,
+			questions,
+			answers: buildAnswers(answerState, questions),
+			cancelled,
+		});
+	}
+
+	function advanceTab(): void {
+		if (!isMulti) {
+			finish(false);
+			return;
+		}
+		switchTab(currentTab < questions.length - 1 ? currentTab + 1 : questions.length);
+	}
+
+	editor.onSubmit = (value) => {
+		const trimmed = value.trim();
+		if (otherMode && otherQuestionId) {
+			saveOtherAnswer(answerState, questions, otherQuestionId, trimmed);
+			otherMode = false;
+			otherQuestionId = null;
+			editor.setText("");
+			advanceTab();
+			return;
+		}
+
+		const question = getCurrentQuestion();
+		if (question?.type === "text") {
+			saveTextAnswer(answerState, question.id, trimmed);
+			editor.setText(trimmed);
+			advanceTab();
+		}
+	};
+
+	if (questions[0]?.type === "text") {
+		editor.setText(answerState.textAnswers.get(questions[0].id) ?? "");
+	}
+
+	return {
+		render(width) {
+			if (cachedLines) return cachedLines;
+			cachedLines = renderForm({
+				title: input.title,
+				description: input.description,
+				questions,
+				answerState,
+				currentTab,
+				cursorIdx,
+				otherMode,
+				width,
+				theme,
+				editorLines: editor.render(Math.min(width, 120) - (otherMode ? 6 : 4)),
+				editorText: editor.getText(),
+			});
+			return cachedLines;
+		},
+		invalidate() {
+			cachedLines = undefined;
+		},
+		handleInput(data) {
+			if (otherMode) {
+				if (matchesKey(data, Key.escape)) {
+					otherMode = false;
+					otherQuestionId = null;
+					editor.setText("");
+					refresh();
+					return;
+				}
+				if (matchesKey(data, Key.enter) && otherQuestionId) {
+					saveOtherModeText(otherQuestionId);
+					advanceTab();
+					return;
+				}
+				if (isMulti && (matchesKey(data, Key.tab) || matchesKey(data, Key.shift("tab"))) && otherQuestionId) {
+					saveOtherModeText(otherQuestionId);
+					switchTab(currentTab + (matchesKey(data, Key.shift("tab")) ? -1 : 1));
+					return;
+				}
+				editor.handleInput(data);
+				refresh();
+				return;
+			}
+
+			const question = getCurrentQuestion();
+			if (question?.type === "text") {
+				if (matchesKey(data, Key.enter)) {
+					saveCurrentTextQuestion();
+					advanceTab();
+					return;
+				}
+				if (isMulti && (matchesKey(data, Key.tab) || matchesKey(data, Key.shift("tab")))) {
+					saveCurrentTextQuestion();
+					switchTab(currentTab + (matchesKey(data, Key.shift("tab")) ? -1 : 1));
+					return;
+				}
+				if (matchesKey(data, Key.escape)) {
+					finish(true);
+					return;
+				}
+				editor.handleInput(data);
+				refresh();
+				return;
+			}
+
+			if (isMulti && currentTab === questions.length) {
+				if (matchesKey(data, Key.enter) && allRequiredAnswered(answerState, questions)) {
+					finish(false);
+					return;
+				}
+				if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+					switchTab(0);
+					return;
+				}
+				if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+					switchTab(currentTab - 1);
+					return;
+				}
+				if (matchesKey(data, Key.escape)) {
+					finish(true);
+					return;
+				}
+				return;
+			}
+
+			if (!question) return;
+
+			if (isMulti) {
+				if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+					switchTab(currentTab + 1);
+					return;
+				}
+				if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+					switchTab(currentTab - 1);
+					return;
+				}
+			}
+
+			const totalOptions = optionCount(question);
+			if (matchesKey(data, Key.up)) {
+				cursorIdx = Math.max(0, cursorIdx - 1);
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.down)) {
+				cursorIdx = Math.min(totalOptions - 1, cursorIdx + 1);
+				refresh();
+				return;
+			}
+			if (matchesKey(data, Key.escape)) {
+				finish(true);
+				return;
+			}
+
+			if (question.type === "radio" && matchesKey(data, Key.enter)) {
+				const isOther = question.allowOther && cursorIdx === question.options.length;
+				if (isOther) {
+					otherMode = true;
+					otherQuestionId = question.id;
+					const existing = answerState.radioAnswers.get(question.id);
+					editor.setText(existing?.wasCustom ? existing.label : "");
+					refresh();
+					return;
+				}
+
+				const option = question.options[cursorIdx];
+				if (option) {
+					answerState.radioAnswers.set(question.id, { value: option.value, label: option.label, wasCustom: false });
+					advanceTab();
+				}
+				return;
+			}
+
+			if (question.type === "checkbox" && matchesKey(data, Key.space)) {
+				const isOther = question.allowOther && cursorIdx === question.options.length;
+				if (isOther) {
+					otherMode = true;
+					otherQuestionId = question.id;
+					editor.setText(answerState.checkCustom.get(question.id) ?? "");
+					refresh();
+					return;
+				}
+
+				const option = question.options[cursorIdx];
+				if (option) {
+					const selected = answerState.checkAnswers.get(question.id) ?? new Set<string>();
+					if (selected.has(option.value)) selected.delete(option.value);
+					else selected.add(option.value);
+					answerState.checkAnswers.set(question.id, selected);
+					refresh();
+				}
+				return;
+			}
+
+			if (question.type === "checkbox" && matchesKey(data, Key.enter)) {
+				advanceTab();
+			}
+		},
+		getState() {
+			return { currentTab, cursorIdx, otherMode, otherQuestionId };
+		},
+	};
+}

package/form-ui.test.ts

@@ -0,0 +1,57 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+
+import { createEditorTheme, runAskUserQuestionForm } from "./form-ui.ts";
+import { normalizeQuestions } from "./state.ts";
+import type { FormResult, RenderTheme } from "./types.ts";
+
+const theme: RenderTheme = {
+	fg: (_color, text) => text,
+	bg: (_color, text) => `[${text}]`,
+	bold: (text) => text,
+};
+
+describe("ask-user-question/form-ui", () => {
+	it("creates the editor theme mapping", () => {
+		const editorTheme = createEditorTheme(theme);
+		expect(editorTheme.borderColor("x")).toBe("x");
+		expect(editorTheme.selectList.selectedPrefix("a")).toBe("a");
+		expect(editorTheme.selectList.selectedText("b")).toBe("b");
+		expect(editorTheme.selectList.description("c")).toBe("c");
+		expect(editorTheme.selectList.scrollInfo("d")).toBe("d");
+		expect(editorTheme.selectList.noMatch("e")).toBe("e");
+	});
+
+	it("wires the custom UI factory to the controller", async () => {
+		const questions = normalizeQuestions([{ id: "text", type: "text", prompt: "Explain", default: "seed" }]);
+		let captured: FormResult | undefined;
+		const done = vi.fn((result: unknown) => {
+			captured = result as FormResult;
+		});
+		const requestRender = vi.fn();
+		const custom = vi.fn(async (factory: Parameters<NonNullable<ExtensionContext["ui"]>["custom"]>[0]) => {
+			const component = (await factory({ requestRender } as never, theme as never, {} as never, done)) as {
+				handleInput(data: string): void;
+			};
+			component.handleInput("!");
+			component.handleInput("\r");
+			expect(requestRender).toHaveBeenCalled();
+			if (!captured) throw new Error("result was not captured");
+			return captured;
+		});
+
+		const ctx = {
+			hasUI: true,
+			ui: { custom },
+		} as unknown as ExtensionContext;
+
+		const result = await runAskUserQuestionForm(ctx, { title: "Title", description: "Desc" }, questions);
+		expect(custom).toHaveBeenCalledTimes(1);
+		expect(result).toEqual({
+			title: "Title",
+			questions,
+			answers: [{ id: "text", type: "text", value: "seed!", wasCustom: true }],
+			cancelled: false,
+		});
+	});
+});