@zhushanwen/pi-ask-user 0.0.4 → 0.2.0

package/src/__tests__/component-keymap.test.ts

@@ -0,0 +1,522 @@
+// src/__tests__/component-keymap.test.ts
+// Key leak regression tests (#1 parseKey whitelist interception)
+import { describe, expect, it } from "vitest";
+
+import { AskUserComponent } from "../component";
+import type { Question } from "../types";
+import {
+	ALT_DOWN,
+	ALT_LEFT,
+	ALT_RIGHT,
+	ALT_UP,
+	APC,
+	BKSP,
+	CTRL_DOWN,
+	CTRL_LEFT,
+	CTRL_RIGHT,
+	CTRL_SHIFT_DOWN,
+	CTRL_SHIFT_UP,
+	CTRL_UP,
+	DA1,
+	DA2,
+	DCS,
+	DELETE,
+	DOWN,
+	END,
+	ENTER,
+	ESC,
+	F1,
+	HOME,
+	INSERT,
+	LEFT,
+	make,
+	multiQWithComment,
+	OSC_BEL,
+	OSC_ST,
+	PAGE_DOWN,
+	PAGE_UP,
+	RIGHT,
+	SHIFT_DOWN,
+	SHIFT_LEFT,
+	SHIFT_RIGHT,
+	SHIFT_UP,
+	singleQ,
+	SUPER_DOWN,
+	SUPER_LEFT,
+	SUPER_RIGHT,
+	SUPER_UP,
+	TAB,
+	UNKNOWN_CSI,
+	UNKNOWN_SS3,
+	UP,
+} from "./fixtures";
+
+/** Helper: 打开 comment 编辑器并返回 component（多问题避免单问题 auto-submit） */
+function openComment(): AskUserComponent {
+	const { c } = make(multiQWithComment);
+	// Q1 (allowComment): select A → enters comment mode
+	c.handleInput(ENTER);
+	return c;
+}
+
+/** Helper: 打开 freeform 编辑器并返回 component（不渲染，避免缓存） */
+function openFreeform(q: Question[]): AskUserComponent {
+	const { c } = make(q);
+	// Navigate to Other (last option) and open editor
+	for (let i = 0; i < 10; i++) c.handleInput(DOWN); // go to last
+	c.handleInput(ENTER); // open freeform
+	return c;
+}
+
+describe("AskUserComponent — key leak fix (C-ARROW / C-KEYMAP)", () => {
+	// ── C-ARROW-1: 连按 3 次右箭头，editorText 不含 [ 或 C ──
+	it("C-ARROW-1: arrow keys do not leak escape sequences into editorText", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(RIGHT); // \x1b[C — should be no-op
+		c.handleInput(RIGHT);
+		c.handleInput(RIGHT);
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		// BUG: before fix, [C[C[C would appear. After fix: editorText stays empty.
+		expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+	});
+
+	// ── C-ARROW-2: direction keys + text input → correct cursor behavior ──
+	it("C-ARROW-2: mixed arrow keys and text input with cursor movement", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(DOWN);   // no-op
+		c.handleInput(RIGHT);  // no-op (empty text)
+		c.handleInput("a");   // insert at 0 → "a", cursor=1
+		c.handleInput(UP);     // no-op
+		c.handleInput(LEFT);   // cursor 1→0
+		c.handleInput("b");   // insert at 0 → "ba", cursor=1
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		// cursor at 1: "b█a" — 去 ANSI 后文本为 "ba"（精确顺序证明 insert 位置：b 在 a 前）
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("ba");
+		// Ensure no leaked sequences
+		expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+	});
+
+	// ── C-KEYMAP-UP: up key no-op in editor ──
+	it("C-KEYMAP-UP: up arrow is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a");
+		c.handleInput(UP);
+		c.handleInput("b");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("ab");
+	});
+
+	// ── C-KEYMAP-DOWN: down key no-op in editor ──
+	it("C-KEYMAP-DOWN: down arrow is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a");
+		c.handleInput(DOWN);
+		c.handleInput("b");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("ab");
+	});
+
+	// ── C-KEYMAP-LEFT: left arrow moves cursor ──
+	it("C-KEYMAP-LEFT: left arrow moves cursor left in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("ab");  // "ab", cursor=2
+		c.handleInput(LEFT);   // cursor 2→1
+		c.handleInput("c");   // insert at 1 → "acb", cursor=2
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		// cursor at 2: "ac█b" — 去 ANSI 后精确文本 "acb"（证明 c 插在 a 与 b 之间）
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("acb");
+	});
+
+	// ── C-KEYMAP-HOME: home key moves cursor to start ──
+	it("C-KEYMAP-HOME: home key moves cursor to start in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(HOME);    // cursor 3→0
+		c.handleInput("d");    // insert at 0 → "dabc", cursor=1
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		// cursor at 1: "d\x1b[7ma\x1b[27mbc" — 去 ANSI 后精确文本 "dabc"（证明 d 插在开头）
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("dabc");
+	});
+
+	// ── C-KEYMAP-END: end key moves cursor to end ──
+	it("C-KEYMAP-END: end key moves cursor to end in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(HOME);    // cursor 3→0
+		c.handleInput(END);     // cursor 0→3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		// cursor at 4 (end): "abcd█"
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-INSERT: insert key no-op (cursor preserved) ──
+	it("C-KEYMAP-INSERT: insert key is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(INSERT);  // no-op, cursor stays at 3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-PGUP: page up no-op (cursor preserved) ──
+	it("C-KEYMAP-PGUP: page up is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(PAGE_UP); // no-op, cursor stays at 3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-PGDN: page down no-op (cursor preserved) ──
+	it("C-KEYMAP-PGDN: page down is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(PAGE_DOWN); // no-op, cursor stays at 3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-F1: f1 key no-op (cursor preserved) ──
+	it("C-KEYMAP-F1: F1 key is no-op in freeform editor", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(F1);      // no-op, cursor stays at 3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-DELETE: delete key no-op (not backspace) ──
+	it("C-KEYMAP-DELETE: delete key is no-op in freeform editor (not backspace)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");  // cursor=3
+		c.handleInput(DELETE);  // no-op, cursor stays at 3
+		c.handleInput("d");    // insert at 3 → "abcd", cursor=4
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("abcd");
+	});
+
+	// ── C-KEYMAP-TAB: Tab 在编辑器内 no-op（不切 tab、不泄漏）──
+	it("C-KEYMAP-TAB: Tab is no-op in freeform editor (no tab switch, no leak)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a");
+		c.handleInput(TAB);  // parseKey 命中 "tab" 但编辑器无对应分支 → no-op
+		c.handleInput("b");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("ab");
+		expect(stripped).not.toContain("\t");
+	});
+
+	// ── C-KEYMAP-SPACE: space character appends correctly ──
+	it("C-KEYMAP-SPACE: space character is appended (parseKey special case)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a");
+		c.handleInput(" "); // space — parseKey(" ") returns "space" not a printable char
+		c.handleInput("b");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("a b");
+	});
+
+	// ── C-KEYMAP-ESC: Esc in editor still works (semantic key) ──
+	it("C-KEYMAP-ESC: Esc in freeform still discards and returns to options", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");
+		c.handleInput(ESC); // should discard and go back to options
+		const lines = c.render(60);
+		// No more editor (back in options mode)
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(false);
+	});
+
+	// ── C-KEYMAP-BKSP: backspace still works (semantic key) ──
+	it("C-KEYMAP-BKSP: backspace still deletes last char", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("abc");
+		c.handleInput(BKSP); // delete 'c'
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("ab");
+		expect(editorLine).not.toContain("abc");
+	});
+
+	// ── C-KEYMAP-COMMENT-UP: arrow key no-op in comment editor too ──
+	it("C-KEYMAP-COMMENT-UP: arrow keys are no-op in comment editor", () => {
+		const c = openComment();
+		c.handleInput("a");
+		c.handleInput(UP);
+		c.handleInput(RIGHT);
+		c.handleInput("b");
+		// comment editor renders text and cursor on separate lines;
+		// check the text line (before cursor) contains "ab"
+		const lines = c.render(60);
+		const textLine = lines.find((l) => l.includes("ab"));
+		expect(textLine).toBeDefined();
+		expect(textLine).toContain("ab");
+		// Ensure no leaked bracket characters from arrow escape sequences
+		const allText = lines.join("\n");
+		expect(allText).not.toMatch(/\[A/); // no leaked UP sequence
+		expect(allText).not.toMatch(/\[C/); // no leaked RIGHT sequence
+	});
+
+	// ── C-KEYMAP-MOD: modifier key combinations matrix (18 cases) ──
+	const modifierCases: Array<{ name: string; seq: string }> = [
+		{ name: "ctrl+up", seq: CTRL_UP },
+		{ name: "ctrl+down", seq: CTRL_DOWN },
+		{ name: "ctrl+left", seq: CTRL_LEFT },
+		{ name: "ctrl+right", seq: CTRL_RIGHT },
+		{ name: "alt+up", seq: ALT_UP },
+		{ name: "alt+down", seq: ALT_DOWN },
+		{ name: "alt+left", seq: ALT_LEFT },
+		{ name: "alt+right", seq: ALT_RIGHT },
+		{ name: "shift+up", seq: SHIFT_UP },
+		{ name: "shift+down", seq: SHIFT_DOWN },
+		{ name: "shift+left", seq: SHIFT_LEFT },
+		{ name: "shift+right", seq: SHIFT_RIGHT },
+		{ name: "super+up", seq: SUPER_UP },
+		{ name: "super+down", seq: SUPER_DOWN },
+		{ name: "super+left", seq: SUPER_LEFT },
+		{ name: "super+right", seq: SUPER_RIGHT },
+		{ name: "ctrl+shift+up", seq: CTRL_SHIFT_UP },
+		{ name: "ctrl+shift+down", seq: CTRL_SHIFT_DOWN },
+	];
+
+	for (const { name, seq } of modifierCases) {
+		it(`C-KEYMAP-MOD-${name}: ${name} modifier combo is no-op in editor`, () => {
+			const c = openFreeform([singleQ]);
+			c.handleInput("x");
+			c.handleInput(seq); // modifier combo → should be no-op
+			c.handleInput("y");
+			const lines = c.render(60);
+			const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+			expect(editorLine).toBeDefined();
+			expect(editorLine).toContain("xy");
+			// No leaked characters from the escape sequence
+			expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+			expect(editorLine).not.toContain(";");
+		});
+	}
+});
+
+describe("AskUserComponent — unknown control sequence leak fix (C-CSI)", () => {
+	it("C-CSI-1: unknown CSI sequence does not leak into editorText", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(UNKNOWN_CSI);
+		c.handleInput("a");
+		c.handleInput("b");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("ab");
+		expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+		expect(editorLine).not.toContain("9");
+		expect(editorLine).not.toContain("~");
+	});
+
+	it("C-CSI-2: OSC11 background color response (BEL) does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(OSC_BEL);
+		c.handleInput("x");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("x");
+		expect(editorLine).not.toContain("]");
+		expect(editorLine).not.toContain("rgb");
+	});
+
+	it("C-CSI-3: OSC11 background color response (ST) does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(OSC_ST);
+		c.handleInput("y");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("y");
+		expect(editorLine).not.toContain("]");
+		expect(editorLine).not.toContain("rgb");
+	});
+
+	it("C-CSI-4: DA2 device attribute response does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(DA2);
+		c.handleInput("m");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("m");
+		expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+	});
+
+	it("C-CSI-5: DA1 device attribute response does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(DA1);
+		c.handleInput("n");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("n");
+		expect(editorLine).not.toContain("?");
+	});
+
+	it("C-CSI-6: DCS XTVersion response does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(DCS);
+		c.handleInput("d");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("d");
+		expect(editorLine).not.toContain("tmux");
+	});
+
+	it("C-CSI-7: APC Kitty graphics response does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(APC);
+		c.handleInput("e");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("e");
+		expect(editorLine).not.toContain("G");
+	});
+
+	it("C-CSI-8: unknown SS3 sequence does not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(UNKNOWN_SS3);
+		c.handleInput("f");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("f");
+		expect(editorLine).not.toContain("O");
+		expect(editorLine).not.toContain("Z");
+	});
+
+	it("C-CSI-9: multiple unknown sequences in a row do not leak", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput(UNKNOWN_CSI);
+		c.handleInput(DA2);
+		c.handleInput("ok");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		expect(editorLine).toContain("ok");
+		expect(editorLine).not.toContain("\x1b[A"); expect(editorLine).not.toContain("\x1b[B"); expect(editorLine).not.toContain("\x1b[C"); expect(editorLine).not.toContain("\x1b[D");
+	});
+
+	it("C-CSI-10: unknown CSI does not leak in comment editor", () => {
+		const c = openComment();
+		c.handleInput(UNKNOWN_CSI);
+		c.handleInput("ab");
+		const lines = c.render(60);
+		const textLine = lines.find((l) => l.includes("ab"));
+		expect(textLine).toBeDefined();
+		expect(textLine).toContain("ab");
+		const allText = lines.join("\n");
+		expect(allText).not.toMatch(/\[9/);
+	});
+
+	it("C-CSI-R1: plain text still appended correctly", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("hello");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("hello");
+	});
+
+	it("C-CSI-R2: emoji still appended correctly", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("fix the 🐛 bug");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("fix the 🐛 bug");
+	});
+
+	it("C-CSI-R3: Chinese text still appended correctly", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("你好");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("你好");
+	});
+
+	it("C-CSI-R4: bracketed paste still works", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("\x1b[200~hello\x1b[201~");
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toContain("hello");
+		expect(editorLine).not.toContain("[200~");
+	});
+});
+
+// 🐛 = U+1F41B，UTF-16 surrogate pair（占 2 个 code unit，index 1=高代理 / 2=低代理）。
+// 验证光标移动/Backspace 按整个 code point 跳跃，不会停在代理中间（index 2）拆散 emoji。
+describe("C-SURROGATE: cursor movement across surrogate pairs", () => {
+	it("C-SUR-BS: backspace at end deletes a full surrogate pair (deleteCount=2)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("ab🐛"); // 🐛 在末尾，cursorIndex=4（a b 高 低）
+		c.handleInput(BKSP);   // 删整个 🐛（非半个低代理），cursorIndex 4→2
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("ab");
+		expect(stripped).not.toContain("🐛");
+	});
+
+	it("C-SUR-RIGHT: Right skips surrogate middle (cursor 1→3, not 2)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a🐛b"); // cursorIndex=4
+		c.handleInput(HOME);   // cursor 4→0
+		c.handleInput(RIGHT);  // cursor 0→1（a 后；isHighSurrogate(0)='a'→ false）
+		c.handleInput(RIGHT);  // cursor 1→3（isHighSurrogate(1)=高代理 → 跳 2，不停在代理中间 2）
+		c.handleInput("X");    // 在 cursor 3 插入 → "a🐛Xb"（X 在 🐛 后、b 前）
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		// X 落在 🐛 之后证明 cursor 跳到了 3；若停在代理中间 2 会拆散 🐛，不含完整 "a🐛Xb"
+		expect(stripped).toContain("a🐛Xb");
+	});
+
+	it("C-SUR-LEFT: Left skips surrogate middle (cursor 4→1, not 2)", () => {
+		const c = openFreeform([singleQ]);
+		c.handleInput("a🐛b"); // cursorIndex=4
+		c.handleInput(END);    // cursor 4（保险，已在末尾）
+		c.handleInput(LEFT);   // cursor 4→3（🐛 与 b 之间）
+		c.handleInput(LEFT);   // cursor 3→1（newLeft-1=高代理 → 跳 2，不停在代理中间 2）
+		c.handleInput("Y");    // 在 cursor 1 插入 → "aY🐛b"（Y 在 🐛 前）
+		const lines = c.render(60);
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
+		expect(editorLine).toBeDefined();
+		const stripped = editorLine!.replace(/\x1b\[[0-9;]*m/g, "");
+		// Y 落在 🐛 之前证明 cursor 跳到了 1；若停在代理中间 2 会拆散 🐛，不含完整 "aY🐛b"
+		expect(stripped).toContain("aY🐛b");
+	});
+});

package/src/__tests__/component.test.ts

@@ -288,7 +288,7 @@ describe("AskUserComponent — Other free-text editor", () => {
 		c.handleInput(ENTER);
 		const lines = c.render(60);
 		// freeform 模式：光标行（█）出现，editor 已在 Other 行原地渲染
-		expect(lines.some((l) => l.includes("█"))).toBe(true);
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(true);
 		// 不再独立 "Your answer" 提示块
 		expect(lines.some((l) => l.includes("Your answer"))).toBe(false);
 	});
@@ -300,7 +300,7 @@ describe("AskUserComponent — Other free-text editor", () => {
 		c.handleInput(TAB);
 		const lines = c.render(60);
 		// Tab 不再打开 Other 编辑器（仅 Enter）；单问题下 Tab 是 no-op
-		expect(lines.some((l) => l.includes("█"))).toBe(false);
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(false);
 	});
 
 	it("C-27: editor accepts printable characters", () => {
@@ -334,7 +334,7 @@ describe("AskUserComponent — Other free-text editor", () => {
 		c.handleInput(ESC);
 		const lines = c.render(60);
 		// Back in options mode — no cursor block (freeform inactive)
-		expect(lines.some((l) => l.includes("█"))).toBe(false);
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(false);
 	});
 
 	it("C-29: editor Enter with text saves and submits (single)", () => {
@@ -358,7 +358,7 @@ describe("AskUserComponent — Other free-text editor", () => {
 		expect(result.val).toBeUndefined();
 		// Back in options mode — no cursor block (freeform inactive)
 		const lines = c.render(60);
-		expect(lines.some((l) => l.includes("█"))).toBe(false);
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(false);
 	});
 });
 
@@ -374,7 +374,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput(ENTER); // 打开 freeform 编辑器
 		c.handleInput("hello world"); // 一次粘贴多字符
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toBeDefined();
 		// 完整文本保留（非仅首字符 "h"）
 		expect(editorLine).toContain("hello world");
@@ -388,7 +388,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput(ENTER);
 		c.handleInput("fix the 🐛 bug");
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toBeDefined();
 		// emoji 完整保留，不丢失
 		expect(editorLine).toContain("fix the 🐛 bug");
@@ -403,7 +403,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput(ENTER);
 		c.handleInput("ab\tcd");
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toBeDefined();
 		// 可打印字符保留，控制字符 \t 被过滤
 		expect(editorLine).toContain("abcd");
@@ -422,7 +422,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		expect(result.val).toBeUndefined();
 		expect(after).toEqual(before);
 		// 编辑器仍在（光标在），editorText 仍为空
-		expect(after.some((l) => l.includes("█"))).toBe(true);
+		expect(after.some((l) => l.includes("\x1b[7m"))).toBe(true);
 	});
 
 	it("C-PASTE-5: single printable char still works (backward-compat)", () => {
@@ -433,7 +433,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput(ENTER);
 		c.handleInput("x"); // 单字符
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toBeDefined();
 		expect(editorLine).toContain("x");
 	});
@@ -448,7 +448,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput(ENTER); // 打开 freeform
 		c.handleInput("\x1b[200~hello\x1b[201~");
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toBeDefined();
 		expect(editorLine).toContain("hello");
 		expect(editorLine).not.toContain("[200~");
@@ -465,7 +465,7 @@ describe("AskUserComponent — multi-char paste in editor", () => {
 		c.handleInput("\x1b[200~foo ");
 		c.handleInput(" bar\x1b[201~");
 		const lines = c.render(60);
-		const editorLine = lines.find((l) => l.includes("█"));
+		const editorLine = lines.find((l) => l.includes("\x1b[7m"));
 		expect(editorLine).toContain("foo  bar");
 		expect(editorLine).not.toContain("[200~");
 		expect(editorLine).not.toContain("[201~");
@@ -592,6 +592,29 @@ describe("AskUserComponent — re-entry guard", () => {
 		c.handleInput(ENTER); // ignored
 		expect(result.val).toBeNull();
 	});
+
+	// FR-12 竞态：signal abort 可能在用户已 submit 后才触发，此时 cancel() 必须是
+	// no-op，避免二次调 done（用户已拿到 submit 结果，不应被 abort 覆盖为 null）。
+	it("C-FR12 (FR-12): cancel() after submit does not re-invoke done", () => {
+		const { c, result } = make([singleQ]);
+		c.handleInput(ENTER); // submit → done(result), _resolved=true
+		expect(result.val).toBeDefined();
+		expect(result.val!.cancelled).toBe(false);
+		const submitVal = result.val;
+		// 模拟 signal abort 在 submit 后触发 → cancel() 应被 _resolved 守卫拦截
+		c.cancel();
+		expect(result.val).toBe(submitVal); // 不变 —— done 未被二次调用
+	});
+
+	it("C-FR12b (FR-12): cancel() after cancel does not re-invoke done", () => {
+		const { c, result } = make([singleQ]);
+		c.handleInput(ESC); // overlay
+		c.handleInput(ESC); // cancel → done(null), _resolved=true
+		expect(result.val).toBeNull();
+		// 再次 cancel（模拟 abort 触发）应 no-op
+		c.cancel();
+		expect(result.val).toBeNull(); // 仍为 null，未触发异常
+	});
 });
 
 // ── 5h. 渲染缓存 ───────────────────────────────────────
@@ -798,7 +821,7 @@ describe("AskUserComponent — new behavior (post-refactor)", () => {
 		// 独立 "Your answer" 提示行已消失
 		expect(lines.some((l) => l.includes("Your answer"))).toBe(false);
 		// freeform cursor 出现
-		expect(lines.some((l) => l.includes("█"))).toBe(true);
+		expect(lines.some((l) => l.includes("\x1b[7m"))).toBe(true);
 		// 依然能看见 "Auth" "Search"（普通选项不变）
 		expect(lines.some((l) => l.includes("Auth"))).toBe(true);
 		expect(lines.some((l) => l.includes("Search"))).toBe(true);
@@ -892,4 +915,19 @@ describe("AskUserComponent — new behavior (post-refactor)", () => {
 		c.handleInput(ENTER);
 		expect(result.val).toBeUndefined();
 	});
+
+	it("C-TAB-NOLEAK: Tab in options mode with single question is no-op", () => {
+		const c = new AskUserComponent(
+			[{ question: "Pick one", options: [{ label: "A" }, { label: "B" }] }],
+			mockTui,
+			stubTheme,
+			() => {},
+		);
+		c.handleInput(DOWN);
+		c.handleInput(TAB);
+		// 不应 crash，选项仍可见
+		const lines = c.render(60);
+		expect(lines.some((l: string) => l.includes("A"))).toBe(true);
+		expect(lines.some((l: string) => l.includes("B"))).toBe(true);
+	});
 });

package/src/__tests__/e2e-harness.ts

@@ -72,6 +72,7 @@ export function makeE2E(questions: Question[], opts: E2EOptions = {}): E2EApi {
 		controller.signal,
 		undefined,
 		{
+			mode: hasUI ? "tui" : "print",
 			hasUI,
 			signal: controller.signal,
 			ui: {