@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/question/tests/row-layout.test.ts

@@ -1,136 +1,215 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import { wrapPlain, buildItemBlocks, flattenBlocks, renderSingleSelectRows } from "../row-layout.ts";
 import type { ItemBlock, QuestionOption } from "../types.ts";
 
 const opts = (labels: string[]): QuestionOption[] => labels.map((label) => ({ value: label, label }));
 
-test("wrapPlain: empty → ['']", () => {
-	assert.deepEqual(wrapPlain("", 20), [""]);
-	assert.deepEqual(wrapPlain("   ", 20), [""]);
-});
+describe("row-layout", () => {
+	it("wrapPlain: empty → ['']", () => {
+		expect(wrapPlain("", 20)).toEqual([""]);
+		expect(wrapPlain("   ", 20)).toEqual([""]);
+	});
 
-test("wrapPlain: single word fits", () => {
-	assert.deepEqual(wrapPlain("hello", 20), ["hello"]);
-});
+	it("wrapPlain: single word fits", () => {
+		expect(wrapPlain("hello", 20)).toEqual(["hello"]);
+	});
 
-test("wrapPlain: word longer than width → chunked", () => {
-	assert.deepEqual(wrapPlain("abcdefgh", 3), ["abc", "def", "gh"]);
-});
+	it("wrapPlain: word longer than width → chunked", () => {
+		expect(wrapPlain("abcdefgh", 3)).toEqual(["abc", "def", "gh"]);
+	});
 
-test("wrapPlain: multiple words wrapping", () => {
-	assert.deepEqual(wrapPlain("hello world foo", 7), ["hello", "world", "foo"]);
-	assert.deepEqual(wrapPlain("hello world foo", 11), ["hello world", "foo"]);
-});
+	it("wrapPlain: multiple words wrapping", () => {
+		expect(wrapPlain("hello world foo", 7)).toEqual(["hello", "world", "foo"]);
+		expect(wrapPlain("hello world foo", 11)).toEqual(["hello world", "foo"]);
+	});
 
-test("wrapPlain: width=1 → char-by-char", () => {
-	assert.deepEqual(wrapPlain("abc", 1), ["a", "b", "c"]);
-});
+	it("wrapPlain: width=1 → char-by-char", () => {
+		expect(wrapPlain("abc", 1)).toEqual(["a", "b", "c"]);
+	});
 
-test("buildItemBlocks: 3 options, selected=0 → arrow on block 0", () => {
-	const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 0);
-	assert.equal(blocks.length, 3);
-	assert.equal(blocks[0]!.itemIndex, 0);
-	assert.ok(blocks[0]!.lines[0]!.startsWith("→"));
-	assert.ok(blocks[0]!.lines[0]!.includes("1. a"));
-	assert.ok(blocks[1]!.lines[0]!.startsWith(" "));
-});
+	it("wrapPlain: long word mid-sentence chunks and continues", () => {
+		expect(wrapPlain("a verylongwordhere b", 5)).toEqual(["a", "veryl", "ongwo", "rdher", "e b"]);
+	});
 
-test("buildItemBlocks: selected=1 → arrow pointer on block 1", () => {
-	const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 1);
-	assert.ok(blocks[1]!.lines[0]!.startsWith("→"));
-	assert.ok(blocks[0]!.lines[0]!.startsWith(" "));
-});
+	it("buildItemBlocks: 3 options, selected=0 → arrow on block 0", () => {
+		const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 0);
+		expect(blocks).toHaveLength(3);
+		expect(blocks[0]!.itemIndex).toBe(0);
+		expect(blocks[0]!.lines[0]!.startsWith("→")).toBe(true);
+		expect(blocks[0]!.lines[0]!).toContain("1. a");
+		expect(blocks[1]!.lines[0]!.startsWith(" ")).toBe(true);
+	});
 
-test("buildItemBlocks: with description → description lines included", () => {
-	const blocks = buildItemBlocks(
-		[{ value: "a", label: "a", description: "some desc" }],
-		80,
-		false,
-		false,
-		false,
-		0,
-	);
-	assert.ok(blocks[0]!.lines.length > 1);
-	assert.ok(blocks[0]!.lines.some((l) => l.includes("some desc")));
-});
+	it("buildItemBlocks: selected=1 → arrow pointer on block 1", () => {
+		const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 1);
+		expect(blocks[1]!.lines[0]!.startsWith("→")).toBe(true);
+		expect(blocks[0]!.lines[0]!.startsWith(" ")).toBe(true);
+	});
 
-test("buildItemBlocks: hideDescriptions=true → no description lines", () => {
-	const blocks = buildItemBlocks(
-		[{ value: "a", label: "a", description: "some desc" }],
-		80,
-		false,
-		false,
-		false,
-		0,
-		true,
-	);
-	// Only the title line, no description
-	assert.equal(blocks[0]!.lines.length, 1);
-});
+	it("buildItemBlocks: with description → description lines included", () => {
+		const blocks = buildItemBlocks(
+			[{ value: "a", label: "a", description: "some desc" }],
+			80,
+			false,
+			false,
+			false,
+			0,
+		);
+		expect(blocks[0]!.lines.length).toBeGreaterThan(1);
+		expect(blocks[0]!.lines.some((l) => l.includes("some desc"))).toBe(true);
+	});
 
-test("buildItemBlocks: allowFreeform → freeform block appended", () => {
-	const blocks = buildItemBlocks(opts(["a"]), 80, true, false, false, 0);
-	assert.equal(blocks.length, 2);
-	assert.ok(blocks[1]!.lines[0]!.includes("Type custom answer"));
-});
+	it("buildItemBlocks: hideDescriptions=true → no description lines", () => {
+		const blocks = buildItemBlocks(
+			[{ value: "a", label: "a", description: "some desc" }],
+			80,
+			false,
+			false,
+			false,
+			0,
+			true,
+		);
+		// Only the title line, no description
+		expect(blocks[0]!.lines).toHaveLength(1);
+	});
 
-test("buildItemBlocks: allowComment → comment-toggle block appended", () => {
-	const blocks = buildItemBlocks(opts(["a"]), 80, false, true, false, 0);
-	assert.equal(blocks.length, 2);
-	assert.ok(blocks[1]!.lines[0]!.includes("[ ]"));
-	assert.ok(blocks[1]!.lines[0]!.includes("Add extra context"));
-});
+	it("buildItemBlocks: allowFreeform → freeform block appended", () => {
+		const blocks = buildItemBlocks(opts(["a"]), 80, true, false, false, 0);
+		expect(blocks).toHaveLength(2);
+		expect(blocks[1]!.lines[0]!).toContain("Type custom answer");
+	});
 
-test("buildItemBlocks: allowComment + commentEnabled → [✓]", () => {
-	const blocks = buildItemBlocks(opts(["a"]), 80, false, true, true, 0);
-	assert.ok(blocks[1]!.lines[0]!.includes("[✓]"));
-});
+	it("buildItemBlocks: allowComment → comment-toggle block appended", () => {
+		const blocks = buildItemBlocks(opts(["a"]), 80, false, true, false, 0);
+		expect(blocks).toHaveLength(2);
+		expect(blocks[1]!.lines[0]!).toContain("[ ]");
+		expect(blocks[1]!.lines[0]!).toContain("Add extra context");
+	});
 
-test("flattenBlocks: correct selected flags", () => {
-	const blocks: ItemBlock[] = [
-		{ itemIndex: 0, lines: ["a", "b"] },
-		{ itemIndex: 1, lines: ["c"] },
-	];
-	const rows = flattenBlocks(blocks, 1);
-	assert.equal(rows.length, 3);
-	assert.equal(rows[0]!.selected, false);
-	assert.equal(rows[1]!.selected, false);
-	assert.equal(rows[2]!.selected, true);
-});
+	it("buildItemBlocks: allowComment + commentEnabled → [✓]", () => {
+		const blocks = buildItemBlocks(opts(["a"]), 80, false, true, true, 0);
+		expect(blocks[1]!.lines[0]!).toContain("[✓]");
+	});
 
-test("renderSingleSelectRows: few rows, all visible", () => {
-	const rows = renderSingleSelectRows({
-		options: opts(["a", "b"]),
-		selectedIndex: 0,
-		width: 80,
-		allowFreeform: false,
+	it("buildItemBlocks: narrow width wraps labels", () => {
+		const blocks = buildItemBlocks(opts(["a very long label"]), 12, false, false, false, 0);
+		expect(blocks[0]!.lines.length).toBeGreaterThan(1);
 	});
-	assert.equal(rows.length, 2);
-});
 
-test("renderSingleSelectRows: maxRows truncation with indicator", () => {
-	const rows = renderSingleSelectRows({
-		options: opts(["a", "b", "c", "c", "e", "f", "g", "h"]),
-		selectedIndex: 0,
-		width: 80,
-		allowFreeform: false,
-		maxRows: 3,
-	});
-	assert.ok(rows.length <= 3);
-	// Last row should be the indicator
-	assert.ok(rows[rows.length - 1]!.line.includes("("));
-});
+	it("flattenBlocks: correct selected flags", () => {
+		const blocks: ItemBlock[] = [
+			{ itemIndex: 0, lines: ["a", "b"] },
+			{ itemIndex: 1, lines: ["c"] },
+		];
+		const rows = flattenBlocks(blocks, 1);
+		expect(rows).toHaveLength(3);
+		expect(rows[0]!.selected).toBe(false);
+		expect(rows[1]!.selected).toBe(false);
+		expect(rows[2]!.selected).toBe(true);
+	});
+
+	it("renderSingleSelectRows: few rows, all visible", () => {
+		const rows = renderSingleSelectRows({
+			options: opts(["a", "b"]),
+			selectedIndex: 0,
+			width: 80,
+			allowFreeform: false,
+		});
+		expect(rows).toHaveLength(2);
+	});
+
+	it("renderSingleSelectRows: maxRows truncation with indicator", () => {
+		const rows = renderSingleSelectRows({
+			options: opts(["a", "b", "c", "c", "e", "f", "g", "h"]),
+			selectedIndex: 0,
+			width: 80,
+			allowFreeform: false,
+			maxRows: 3,
+		});
+		expect(rows.length).toBeLessThanOrEqual(3);
+		// Last row should be the indicator
+		expect(rows[rows.length - 1]!.line).toContain("(");
+	});
 
-test("renderSingleSelectRows: selected block larger than available → only selected + indicator", () => {
-	const rows = renderSingleSelectRows({
-		options: [{ value: "a", label: "a".repeat(100) }],
-		selectedIndex: 0,
-		width: 10,
-		allowFreeform: false,
-		maxRows: 3,
-	});
-	assert.ok(rows.length <= 3);
-	assert.ok(rows.every((r) => r.selected || r.line.includes("(")));
-});
+	it("renderSingleSelectRows: selected block larger than available → only selected + indicator", () => {
+		const rows = renderSingleSelectRows({
+			options: [{ value: "a", label: "a".repeat(100) }],
+			selectedIndex: 0,
+			width: 10,
+			allowFreeform: false,
+			maxRows: 3,
+		});
+		expect(rows.length).toBeLessThanOrEqual(3);
+		expect(rows.every((r) => r.selected || r.line.includes("("))).toBe(true);
+	});
+
+	it("renderSingleSelectRows: maxRows=1 shows only the selected line", () => {
+		const rows = renderSingleSelectRows({
+			options: opts(["a", "b"]),
+			selectedIndex: 0,
+			width: 80,
+			allowFreeform: false,
+			maxRows: 1,
+		});
+		expect(rows.length).toBeLessThanOrEqual(1);
+	});
+
+	it("renderSingleSelectRows: empty options with freeform still renders", () => {
+		const rows = renderSingleSelectRows({
+			options: [],
+			selectedIndex: 0,
+			width: 80,
+			allowFreeform: true,
+			maxRows: 5,
+		});
+		expect(rows.length).toBeGreaterThan(0);
+	});
+
+	it("renderSingleSelectRows: empty options without freeform returns empty", () => {
+		const rows = renderSingleSelectRows({
+			options: [],
+			selectedIndex: 0,
+			width: 80,
+			allowFreeform: false,
+			maxRows: 5,
+		});
+		expect(rows).toEqual([]);
+	});
+
+	it("renderSingleSelectRows: previous block fits when next does not", () => {
+		// Selected block is small; the next block is too large but the previous fits.
+		const rows = renderSingleSelectRows({
+			options: [
+				{ value: "a", label: "A" },
+				{ value: "b", label: "B" },
+				{ value: "c", label: "C".repeat(100) },
+			],
+			selectedIndex: 1,
+			width: 10,
+			allowFreeform: false,
+			maxRows: 3,
+		});
+		expect(rows.length).toBeLessThanOrEqual(3);
+		expect(rows.some((r) => r.line.includes("A"))).toBe(true);
+	});
+
+	it("buildItemBlocks: wrapped freeform label uses continuation prefix", () => {
+		const blocks = buildItemBlocks(opts(["a"]), 12, true, false, false, 1);
+		expect(blocks[1]!.lines.length).toBeGreaterThan(1);
+		expect(blocks[1]!.lines[1]!.startsWith("    ")).toBe(true);
+	});
+
+	it("renderSingleSelectRows: out-of-range selectedIndex falls back to the first block", () => {
+		const rows = renderSingleSelectRows({
+			options: opts(["a", "b"]),
+			selectedIndex: 7,
+			width: 40,
+			allowFreeform: false,
+			maxRows: 1,
+		});
+		expect(rows.length).toBeGreaterThan(0);
+		expect(rows[0]!.selected).toBe(true);
+		expect(rows[0]!.line).toContain("a");
+	});
+});

package/dist/extensions/question/tests/schemas.test.ts

@@ -1,5 +1,4 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import { Value } from "typebox/value";
 
@@ -9,22 +8,46 @@ const valid = {
 	questions: [{ type: "select", question: "Pick", options: [{ value: "yes", label: "Yes" }] }],
 };
 
-test("QuestionParamsSchema accepts typed batch requests", () => {
-	assert.equal(Value.Check(QuestionParamsSchema, valid), true);
-});
+describe("QuestionParamsSchema", () => {
+	it("accepts typed batch requests", () => {
+		expect(Value.Check(QuestionParamsSchema, valid)).toBe(true);
+	});
+
+	it("accepts multiselect, text, ids, labels, context, allowOther, descriptions", () => {
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [
+				{ type: "multiselect", id: "m", label: "M", question: "Pick many", context: "ctx", options: [{ value: "a", label: "A", description: "d" }], allowOther: true },
+				{ type: "text", question: "Explain" },
+			],
+		})).toBe(true);
+	});
+
+	it("rejects legacy and mistyped fields", () => {
+		expect(Value.Check(QuestionParamsSchema, { ...valid, timeout: 1000 })).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ ...valid.questions[0], allowMultiple: true }],
+		})).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ ...valid.questions[0], allowComment: true }],
+		})).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ type: "text", question: "Explain", options: [] }],
+		})).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ ...valid.questions[0], options: [{ value: "yes", label: "Yes", extra: true }] }],
+		})).toBe(false);
+	});
 
-test("QuestionParamsSchema rejects legacy and mistyped fields", () => {
-	assert.equal(Value.Check(QuestionParamsSchema, { ...valid, timeout: 1000 }), false);
-	assert.equal(Value.Check(QuestionParamsSchema, {
-		questions: [{ ...valid.questions[0], allowMultiple: true }],
-	}), false);
-	assert.equal(Value.Check(QuestionParamsSchema, {
-		questions: [{ ...valid.questions[0], allowComment: true }],
-	}), false);
-	assert.equal(Value.Check(QuestionParamsSchema, {
-		questions: [{ type: "text", question: "Explain", options: [] }],
-	}), false);
-	assert.equal(Value.Check(QuestionParamsSchema, {
-		questions: [{ ...valid.questions[0], options: [{ value: "yes", label: "Yes", extra: true }] }],
-	}), false);
+	it("rejects empty questions and bad option shapes", () => {
+		expect(Value.Check(QuestionParamsSchema, { questions: [] })).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ type: "select", question: "Pick", options: [] }],
+		})).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ type: "select", question: "Pick", options: [{ value: "yes" }] }],
+		})).toBe(false);
+		expect(Value.Check(QuestionParamsSchema, {
+			questions: [{ type: "select", question: "Pick", options: [{ label: "Yes" }] }],
+		})).toBe(false);
+	});
 });

package/dist/extensions/question/tests/selection-mode.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+
+import { MultiSelect, SingleSelect } from "../selection-mode.ts";
+
+describe("selection-mode", () => {
+	it("SingleSelect reports single mode and no-op toggle", () => {
+		expect(SingleSelect.multi).toBe(false);
+		const checked = new Set<number>([1]);
+		SingleSelect.toggle(checked, 0);
+		expect([...checked]).toEqual([1]);
+	});
+
+	it("SingleSelect buildResult returns the selected value", () => {
+		const options = [{ value: "a", label: "A" }];
+		expect(SingleSelect.buildResult({ selectedIndex: 0, checked: new Set(), options })).toEqual(["a"]);
+		// Out-of-range index (or empty options) → no value → empty result.
+		expect(SingleSelect.buildResult({ selectedIndex: 2, checked: new Set(), options })).toEqual([]);
+		expect(SingleSelect.buildResult({ selectedIndex: 0, checked: new Set(), options: [] })).toEqual([]);
+	});
+
+	it("SingleSelect handleNumberKey clamps to the last option", () => {
+		expect(SingleSelect.handleNumberKey(5, 3)).toEqual({ toggle: false, selectIndex: 2 });
+		expect(SingleSelect.handleNumberKey(1, 3)).toEqual({ toggle: false, selectIndex: 1 });
+	});
+
+	it("MultiSelect toggle adds, removes, and ignores negative indexes", () => {
+		expect(MultiSelect.multi).toBe(true);
+		const checked = new Set<number>();
+		MultiSelect.toggle(checked, 0);
+		expect(checked.has(0)).toBe(true);
+		MultiSelect.toggle(checked, 0);
+		expect(checked.has(0)).toBe(false);
+		MultiSelect.toggle(checked, -1);
+		expect(checked.size).toBe(0);
+	});
+
+	it("MultiSelect buildResult sorts and filters missing options", () => {
+		const options = [
+			{ value: "a", label: "A" },
+			{ value: "b", label: "B" },
+		];
+		const checked = new Set([1, 0]);
+		expect(MultiSelect.buildResult({ selectedIndex: 0, checked, options })).toEqual(["a", "b"]);
+		// Indexes pointing past the options array are filtered out.
+		const sparse = new Set([0, 1, 2]);
+		expect(MultiSelect.buildResult({ selectedIndex: 0, checked: sparse, options })).toEqual(["a", "b"]);
+		expect(MultiSelect.buildResult({ selectedIndex: 0, checked: new Set(), options })).toEqual([]);
+	});
+
+	it("MultiSelect handleNumberKey clamps to the last option", () => {
+		expect(MultiSelect.handleNumberKey(5, 3)).toEqual({ toggle: true, selectIndex: 2 });
+		expect(MultiSelect.handleNumberKey(0, 3)).toEqual({ toggle: true, selectIndex: 0 });
+	});
+});

package/dist/extensions/question/tests/shortcuts.test.ts

@@ -1,85 +1,107 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { normalizeShortcutSpec, isValidShortcutSpec, resolveShortcut } from "../shortcuts.ts";
-import { DISABLED_SHORTCUT } from "../constants.ts";
-
-test("normalizeShortcutSpec: undefined → undefined", () => {
-	assert.equal(normalizeShortcutSpec(undefined), undefined);
-});
-
-test("normalizeShortcutSpec: null → null", () => {
-	assert.equal(normalizeShortcutSpec(null), null);
-});
-
-test("normalizeShortcutSpec: disable values → null", () => {
-	assert.equal(normalizeShortcutSpec("off"), null);
-	assert.equal(normalizeShortcutSpec("none"), null);
-	assert.equal(normalizeShortcutSpec("disabled"), null);
-	assert.equal(normalizeShortcutSpec(""), null);
-	assert.equal(normalizeShortcutSpec("  off  "), null);
-});
-
-test("normalizeShortcutSpec: normalizes case and trims", () => {
-	assert.equal(normalizeShortcutSpec("Alt+O"), "alt+o");
-	assert.equal(normalizeShortcutSpec("  Ctrl+G  "), "ctrl+g");
+import { describe, expect, it } from "vitest";
+
+import { normalizeShortcutSpec, isValidShortcutSpec, resolveShortcut, resolveShortcuts, buildShortcut } from "../shortcuts.ts";
+import { DISABLED_SHORTCUT, DEFAULT_COMMENT_TOGGLE_KEY } from "../constants.ts";
+
+describe("shortcut resolution", () => {
+	it("normalizeShortcutSpec: undefined → undefined", () => {
+		expect(normalizeShortcutSpec(undefined)).toBeUndefined();
+	});
+
+	it("normalizeShortcutSpec: null → null", () => {
+		expect(normalizeShortcutSpec(null)).toBeNull();
+	});
+
+	it("normalizeShortcutSpec: disable values → null", () => {
+		expect(normalizeShortcutSpec("off")).toBeNull();
+		expect(normalizeShortcutSpec("none")).toBeNull();
+		expect(normalizeShortcutSpec("disabled")).toBeNull();
+		expect(normalizeShortcutSpec("")).toBeNull();
+		expect(normalizeShortcutSpec("  off  ")).toBeNull();
+	});
+
+	it("normalizeShortcutSpec: normalizes case and trims", () => {
+		expect(normalizeShortcutSpec("Alt+O")).toBe("alt+o");
+		expect(normalizeShortcutSpec("  Ctrl+G  ")).toBe("ctrl+g");
+	});
+
+	it("isValidShortcutSpec: empty → false", () => {
+		expect(isValidShortcutSpec("")).toBe(false);
+		expect(isValidShortcutSpec(" ")).toBe(false);
+	});
+
+	it("isValidShortcutSpec: valid specs", () => {
+		expect(isValidShortcutSpec("alt+o")).toBe(true);
+		expect(isValidShortcutSpec("ctrl+g")).toBe(true);
+		expect(isValidShortcutSpec("shift+f1")).toBe(true);
+	});
+
+	it("isValidShortcutSpec: leading/trailing + → false", () => {
+		expect(isValidShortcutSpec("+o")).toBe(false);
+		expect(isValidShortcutSpec("o+")).toBe(false);
+	});
+
+	it("isValidShortcutSpec: double + → false", () => {
+		expect(isValidShortcutSpec("alt++o")).toBe(false);
+	});
+
+	it("isValidShortcutSpec: illegal characters → false", () => {
+		expect(isValidShortcutSpec("alt o")).toBe(false);
+		expect(isValidShortcutSpec("alt\n")).toBe(false);
+	});
+
+	it("buildShortcut returns a matching shortcut", () => {
+		const shortcut = buildShortcut("ctrl+g");
+		expect(shortcut.disabled).toBe(false);
+		expect(shortcut.spec).toBe("ctrl+g");
+		expect(shortcut.matches("\x07")).toBe(true);
+		expect(shortcut.matches("x")).toBe(false);
+	});
+
+	it("resolveShortcut: uses param when valid", () => {
+		const result = resolveShortcut("alt+o", undefined, "alt+o");
+		expect(result.disabled).toBe(false);
+		expect(result.spec).toBe("alt+o");
+	});
+
+	it("resolveShortcut: param undefined, uses env", () => {
+		const result = resolveShortcut(undefined, "ctrl+x", "alt+o");
+		expect(result.disabled).toBe(false);
+		expect(result.spec).toBe("ctrl+x");
+	});
+
+	it("resolveShortcut: param null → disabled", () => {
+		expect(resolveShortcut(null, "ctrl+x", "alt+o")).toBe(DISABLED_SHORTCUT);
+	});
+
+	it("resolveShortcut: param undefined, env undefined, uses default", () => {
+		const result = resolveShortcut(undefined, undefined, "alt+o");
+		expect(result.disabled).toBe(false);
+		expect(result.spec).toBe("alt+o");
+	});
+
+	it("resolveShortcut: param 'off' → disabled", () => {
+		expect(resolveShortcut("off", "ctrl+x", "alt+o")).toBe(DISABLED_SHORTCUT);
+	});
+
+	it("resolveShortcut: invalid param falls through to env", () => {
+		const result = resolveShortcut("invalid++", "ctrl+x", "alt+o");
+		expect(result.disabled).toBe(false);
+		expect(result.spec).toBe("ctrl+x");
+	});
+
+	it("resolveShortcut: all invalid → disabled", () => {
+		expect(resolveShortcut("invalid++", "also++", "default++")).toBe(DISABLED_SHORTCUT);
+	});
+
+	it("resolveShortcuts builds the commentToggle map with the default key", () => {
+		const shortcuts = resolveShortcuts(undefined, undefined);
+		expect(shortcuts.commentToggle.disabled).toBe(false);
+		expect(shortcuts.commentToggle.spec).toBe(DEFAULT_COMMENT_TOGGLE_KEY);
+	});
+
+	it("DISABLED_SHORTCUT matches nothing", () => {
+		expect(DISABLED_SHORTCUT.matches("anything")).toBe(false);
+		expect(DISABLED_SHORTCUT.disabled).toBe(true);
+	});
 });
-
-test("isValidShortcutSpec: empty → false", () => {
-	assert.equal(isValidShortcutSpec(""), false);
-	assert.equal(isValidShortcutSpec(" "), false);
-});
-
-test("isValidShortcutSpec: valid specs", () => {
-	assert.equal(isValidShortcutSpec("alt+o"), true);
-	assert.equal(isValidShortcutSpec("ctrl+g"), true);
-	assert.equal(isValidShortcutSpec("shift+f1"), true);
-});
-
-test("isValidShortcutSpec: leading/trailing + → false", () => {
-	assert.equal(isValidShortcutSpec("+o"), false);
-	assert.equal(isValidShortcutSpec("o+"), false);
-});
-
-test("isValidShortcutSpec: double + → false", () => {
-	assert.equal(isValidShortcutSpec("alt++o"), false);
-});
-
-test("resolveShortcut: uses param when valid", () => {
-	const result = resolveShortcut("alt+o", undefined, "alt+o");
-	assert.equal(result.disabled, false);
-	assert.equal(result.spec, "alt+o");
-});
-
-test("resolveShortcut: param undefined, uses env", () => {
-	const result = resolveShortcut(undefined, "ctrl+x", "alt+o");
-	assert.equal(result.disabled, false);
-	assert.equal(result.spec, "ctrl+x");
-});
-
-test("resolveShortcut: param null → disabled", () => {
-	const result = resolveShortcut(null, "ctrl+x", "alt+o");
-	assert.equal(result, DISABLED_SHORTCUT);
-});
-
-test("resolveShortcut: param undefined, env undefined, uses default", () => {
-	const result = resolveShortcut(undefined, undefined, "alt+o");
-	assert.equal(result.disabled, false);
-	assert.equal(result.spec, "alt+o");
-});
-
-test("resolveShortcut: param 'off' → disabled", () => {
-	const result = resolveShortcut("off", "ctrl+x", "alt+o");
-	assert.equal(result, DISABLED_SHORTCUT);
-});
-
-test("resolveShortcut: invalid param falls through to env", () => {
-	const result = resolveShortcut("invalid++", "ctrl+x", "alt+o");
-	assert.equal(result.disabled, false);
-	assert.equal(result.spec, "ctrl+x");
-});
-
-test("resolveShortcut: all invalid → disabled", () => {
-	const result = resolveShortcut("invalid++", "also++", "default++");
-	assert.equal(result, DISABLED_SHORTCUT);
-});