@gavin-hu/my-pi-agent 0.11.4 → 0.13.0

package/extensions/bytefly/panel/settings-runtime.ts

@@ -11,7 +11,7 @@
 
 import { join } from "node:path";
 import { CONFIG_DIR_NAME, type QuietStartup } from "@earendil-works/pi-coding-agent";
-import { readJson, SHARED_CONFIG_FILE, writeConfigValue } from "../../../lib/config.ts";
+import { readJson, SHARED_CONFIG_FILE, writeConfigValueAt } from "../../../lib/config.ts";
 import type { SettingsStore, WriteScope } from "../picker/types.ts";
 import {
 	countSettings,
@@ -22,6 +22,7 @@ import {
 	SETTING_ROWS,
 	settingViews,
 	storedValue,
+	textError,
 	validValue,
 } from "./settings.ts";
 
@@ -40,7 +41,10 @@ export interface SettingsRuntimeDeps {
 export interface SettingsSurface {
 	views(scope: WriteScope): SettingView[];
 	count(scope: WriteScope): number;
+	/** Cycle an enum or toggle a boolean. */
 	change(scope: WriteScope, id: string): Promise<void>;
+	/** Store a value the user typed; `false` when the row refused it. */
+	setValue(scope: WriteScope, id: string, raw: string): Promise<boolean>;
 	isDirty(): boolean;
 }
 
@@ -81,6 +85,15 @@ function applyAppSetting(store: SettingsStore, row: SettingDescriptor, raw: stri
 	}
 }
 
+/** Why `row` cannot be written in `scope`, or `undefined` when it can. */
+function refusal(row: SettingDescriptor, scope: WriteScope, trusted: boolean): string | undefined {
+	if (scope === "project" && !trusted) {
+		return "Project is not trusted; settings can only be changed in Global scope.";
+	}
+	if (row.source === "app" && scope !== "global") return `${row.label} is a Global setting.`;
+	return undefined;
+}
+
 /** Create the Settings runtime for one screen invocation. */
 export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntime {
 	let snapshot = readSnapshot(deps);
@@ -91,18 +104,42 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 		for (const listener of listeners) listener();
 	};
 
+	/**
+	 * Write one row's value, including the extra leaves the row declares. Throws
+	 * with the reason a write failed; the caller formats it and leaves the
+	 * displayed value alone.
+	 */
+	const write = async (scope: WriteScope, row: SettingDescriptor, raw: string): Promise<void> => {
+		if (row.source === "app") {
+			applyAppSetting(deps.stores.global, row, raw);
+			await deps.stores.global.flush();
+			const first = deps.stores.global.drainErrors()[0];
+			if (first) throw first.error;
+			return;
+		}
+		const config = row.config;
+		if (!config) throw new Error(`Setting ${row.id} has no config section`);
+		const path = configPath(scope, deps.cwd, deps.agentDir);
+		writeConfigValueAt(path, config.section, config.path, storedValue(row, raw));
+		for (const leaf of row.also?.(raw) ?? []) writeConfigValueAt(path, leaf.section, leaf.path, leaf.value);
+	};
+
+	/** Take a completed write: re-read the snapshot, mark it dirty, repaint. */
+	const committed = (): void => {
+		snapshot = readSnapshot(deps);
+		dirty = true;
+		emit();
+	};
+
 	return {
 		views: (scope) => settingViews(snapshot, scope),
 		count: (scope) => countSettings(scope),
 		change: async (scope, id) => {
 			const row = SETTING_ROWS.find((entry) => entry.id === id);
 			if (!row) return;
-			if (scope === "project" && !deps.trusted) {
-				deps.onError?.("Project is not trusted; settings can only be changed in Global scope.");
-				return;
-			}
-			if (row.source === "app" && scope !== "global") {
-				deps.onError?.(`${row.label} is a Global setting.`);
+			const refused = refusal(row, scope, deps.trusted);
+			if (refused !== undefined) {
+				deps.onError?.(refused);
 				return;
 			}
 			const current = settingViews(snapshot, scope).find((entry) => entry.id === id);
@@ -112,32 +149,38 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 				deps.onError?.(`Cannot save ${row.label}: unknown value.`);
 				return;
 			}
-
 			try {
-				if (row.source === "app") {
-					applyAppSetting(deps.stores.global, row, next.value);
-					await deps.stores.global.flush();
-					const errors = deps.stores.global.drainErrors();
-					const first = errors[0];
-					if (first) throw first.error;
-				} else {
-					const config = row.config;
-					if (!config) throw new Error(`Setting ${row.id} has no config section`);
-					writeConfigValue(
-						configPath(scope, deps.cwd, deps.agentDir),
-						config.section,
-						config.key,
-						storedValue(row, next.value),
-					);
-				}
+				await write(scope, row, next.value);
 			} catch (error) {
 				deps.onError?.(`Could not save ${row.label}: ${error instanceof Error ? error.message : String(error)}`);
 				return;
 			}
-
-			snapshot = readSnapshot(deps);
-			dirty = true;
-			emit();
+			committed();
+		},
+		async setValue(scope, id, raw) {
+			const row = SETTING_ROWS.find((entry) => entry.id === id);
+			if (!row || row.kind !== "text") {
+				deps.onError?.(`${row?.label ?? id} cannot be edited as text.`);
+				return false;
+			}
+			const refused = refusal(row, scope, deps.trusted);
+			if (refused !== undefined) {
+				deps.onError?.(refused);
+				return false;
+			}
+			const invalid = textError(row, raw);
+			if (invalid !== undefined) {
+				deps.onError?.(invalid);
+				return false;
+			}
+			try {
+				await write(scope, row, raw);
+			} catch (error) {
+				deps.onError?.(`Could not save ${row.label}: ${error instanceof Error ? error.message : String(error)}`);
+				return false;
+			}
+			committed();
+			return true;
 		},
 		isDirty: () => dirty,
 		onChange: (listener) => {

package/extensions/bytefly/panel/settings.ts

@@ -1,19 +1,29 @@
 /**
  * The Settings section's catalogue and value arithmetic.
  *
- * A row is one preference: an app setting from Pi's `settings.json`, or a key
- * in a `bytefly.json` section. This module is pure — descriptors, a snapshot to
+ * A row is one preference: an app setting from Pi's `settings.json`, or a leaf
+ * of a `bytefly.json` section. This module is pure — descriptors, a snapshot to
  * views, cycling, validation, and grouping — so the screen and the runtime share
  * one definition and the tests need no host.
  *
- * The catalogue is deliberately curated. The schema walker is a later step;
- * five rows prove the row types (boolean checkbox, enum cycle), both scopes,
- * and both write paths first.
+ * The catalogue covers every scalar preference: booleans, enums, short strings,
+ * and — with `doctor.timeoutMs` — a number. Each row states its own rule, so a
+ * value the screen accepts is a value the loader keeps. Arrays (`doctor.skip`),
+ * the `rates` table, and `price.peak` stay JSON edits: a list, a table, and a
+ * nested object are not one row.
  */
 
-import { configSection } from "../../../lib/config.ts";
+import { configSection, configValueAt } from "../../../lib/config.ts";
 import { GLYPHS } from "../../../lib/tui/glyphs.ts";
-import { DEFAULT_CHROME_CONFIG, normalizeChromeConfig } from "../chrome.ts";
+import { DEFAULT_CHROME_CONFIG, isRailGlyph, normalizeChromeConfig } from "../chrome.ts";
+import { DEFAULT_CONFIG as DEFAULT_DOCTOR_CONFIG, normalizeConfig as normalizeDoctorConfig } from "../doctor/config.ts";
+import {
+	CURRENCY_DEFAULTS,
+	DEFAULT_BYTEFLY_CONFIG,
+	DEFAULT_CURRENCY,
+	normalizeByteflyConfig,
+} from "../footer/price/config.ts";
+import type { CurrencyCode } from "../footer/price/types.ts";
 import { DEFAULT_NOTIFY_CONFIG, normalizeNotifyConfig } from "../notify/config.ts";
 import type { Settings, WriteScope } from "../picker/types.ts";
 
@@ -21,7 +31,7 @@ import type { Settings, WriteScope } from "../picker/types.ts";
 export type SettingSource = "app" | "bytefly";
 
 /** The row control a preference uses. */
-export type SettingKind = "boolean" | "enum";
+export type SettingKind = "boolean" | "enum" | "text";
 
 /** Where the effective value came from. */
 export type SettingOrigin = "default" | "global" | "project" | "inherited";
@@ -32,14 +42,35 @@ export interface SettingOption {
 	label: string;
 }
 
+/** What a text row accepts, checked before a write so the file cannot hold less. */
+export interface TextRule {
+	/** Longest accepted value, in the units the loader slices with. */
+	maxLength: number;
+	/** Why `raw` cannot be stored, or `undefined` when it can. */
+	validate?: (raw: string) => string | undefined;
+}
+
 /** One heading in the Settings list. */
 export interface SettingGroup {
 	key: string;
 	label: string;
 }
 
-/** A `bytefly.json` location for a row. */
-type SettingConfig = { section: "notify"; key: "enabled" } | { section: "chrome"; key: "rail" };
+/** The `bytefly.json` sections the Settings section can read and write. */
+export type ConfigSectionName = "notify" | "chrome" | "doctor" | "price";
+
+/** Where a `bytefly.json` row lives: a section, and the path to its leaf. */
+export interface SettingConfig {
+	section: ConfigSectionName;
+	path: readonly string[];
+}
+
+/** One `bytefly.json` leaf a row writes alongside its own. */
+export interface SettingLeaf {
+	section: ConfigSectionName;
+	path: readonly string[];
+	value: unknown;
+}
 
 /** The static definition of one preference. */
 export interface SettingDescriptor {
@@ -51,12 +82,21 @@ export interface SettingDescriptor {
 	description: string;
 	source: SettingSource;
 	kind: SettingKind;
-	/** Curated values, in cycle order. */
+	/** Curated values, in cycle order; empty for a text row. */
 	options: readonly SettingOption[];
+	/** For `kind: "text"`: the length limit and any rule the value must satisfy. */
+	text?: TextRule;
 	/** The value shown when neither file sets the key. */
 	fallback: string;
-	/** For `bytefly` rows: the section and key this row edits. */
+	/** The JSON type the row stores; string when omitted. */
+	json?: "boolean" | "number";
+	/** For `bytefly` rows: the section and leaf path this row edits. */
 	config?: SettingConfig;
+	/**
+	 * Extra leaves written with this row's own, for a value that implies another.
+	 * Kept on the row so the writer stays generic and the rule is stated once.
+	 */
+	also?: (raw: string) => readonly SettingLeaf[];
 }
 
 /** A row with the value read from one scope. */
@@ -86,6 +126,8 @@ export interface GroupedSettings {
 export const SETTING_GROUPS: readonly SettingGroup[] = [
 	{ key: "startup", label: "Startup" },
 	{ key: "notifications", label: "Notifications" },
+	{ key: "diagnostics", label: "Diagnostics" },
+	{ key: "pricing", label: "Pricing" },
 	{ key: "transcript", label: "Transcript" },
 	{ key: "terminal", label: "Terminal" },
 ];
@@ -95,14 +137,49 @@ const ON_OFF: readonly SettingOption[] = [
 	{ value: "true", label: "On" },
 ];
 
-/** Rail glyphs offered in the curated picker; every one is one column. */
-const RAIL_OPTIONS: readonly SettingOption[] = [
-	{ value: GLYPHS.divider, label: GLYPHS.divider },
-	{ value: "│", label: "│" },
-	{ value: "┃", label: "┃" },
-	{ value: "▏", label: "▏" },
+/** The notify section's delivery methods, labeled by the surface each reaches. */
+const METHOD_OPTIONS: readonly SettingOption[] = [
+	{ value: "auto", label: "Auto" },
+	{ value: "osc777", label: "OSC 777" },
+	{ value: "osc99", label: "OSC 99" },
+	{ value: "toast", label: "Windows toast" },
+	{ value: "osascript", label: "macOS" },
+	{ value: "notify-send", label: "Linux" },
 ];
 
+/** Cost precision 0-4, the range the `price` section clamps `decimals` to. */
+const DECIMALS_OPTIONS: readonly SettingOption[] = [0, 1, 2, 3, 4].map((value) => ({
+	value: String(value),
+	label: String(value),
+}));
+
+/**
+ * A text rule for a whole number inside an inclusive range.
+ *
+ * The bounds are the loader's own (`doctor.timeoutMs` is clamped to 100-30000),
+ * so an accepted value is never silently clamped on the next read. `maxLength`
+ * only stops a runaway buffer; `validate` is the rule.
+ */
+function integerRule(min: number, max: number): TextRule {
+	return {
+		maxLength: String(max).length + 2,
+		validate(raw) {
+			const text = raw.trim();
+			if (!/^\d+$/.test(text)) return `Use a whole number, ${min} to ${max}.`;
+			const value = Number(text);
+			if (value < min || value > max) return `Out of range: ${min} to ${max}.`;
+			return undefined;
+		},
+	};
+}
+
+/** The rail's rule: the loader drops anything that is not one column. */
+const RAIL_RULE: TextRule = {
+	maxLength: 4,
+	validate: (raw) =>
+		isRailGlyph(raw) ? undefined : "Use exactly one column: a single glyph, with no spaces or control characters.",
+};
+
 /** The v1 catalogue, in screen order. */
 export const SETTING_ROWS: readonly SettingDescriptor[] = [
 	{
@@ -113,6 +190,7 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		source: "app",
 		kind: "boolean",
 		fallback: "false",
+		json: "boolean",
 		options: ON_OFF,
 	},
 	{
@@ -123,19 +201,155 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		source: "bytefly",
 		kind: "boolean",
 		fallback: "false",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "notify", path: ["enabled"] },
+	},
+	{
+		id: "notify.turnFinished",
+		group: "notifications",
+		label: "Turn finished",
+		description: "Announce it when a full agent run settles.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "notify", path: ["turnFinished"] },
+	},
+	{
+		id: "notify.needsInput",
+		group: "notifications",
+		label: "Needs input",
+		description: "Announce it when the agent opens a prompt and waits for an answer.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
 		options: ON_OFF,
-		config: { section: "notify", key: "enabled" },
+		config: { section: "notify", path: ["needsInput"] },
+	},
+	{
+		id: "notify.jobFinished",
+		group: "notifications",
+		label: "Job finished",
+		description: "Announce it when a background job or watcher settles.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "notify", path: ["jobFinished"] },
+	},
+	{
+		id: "notify.matchFound",
+		group: "notifications",
+		label: "Watcher matched",
+		description: "Announce it when a `watch` whose `wake` is on matches while the agent is idle.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "notify", path: ["matchFound"] },
+	},
+	{
+		id: "notify.method",
+		group: "notifications",
+		label: "Delivery method",
+		description: "How a notification is delivered; Auto picks from the terminal, then the platform.",
+		source: "bytefly",
+		kind: "enum",
+		fallback: "auto",
+		options: METHOD_OPTIONS,
+		config: { section: "notify", path: ["method"] },
+	},
+	{
+		id: "notify.title",
+		group: "notifications",
+		label: "Notification title",
+		description: "Shown as the title of every OS notification; up to 40 characters.",
+		source: "bytefly",
+		kind: "text",
+		fallback: "Pi",
+		options: [],
+		text: {
+			maxLength: 40,
+			validate: (raw) => (raw.trim() === "" ? "A title is required." : undefined),
+		},
+		config: { section: "notify", path: ["title"] },
+	},
+	{
+		id: "doctor.proactive",
+		group: "diagnostics",
+		label: "Proactive health check",
+		description: "Probe enabled extensions at session start and warn about a missing requirement.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "doctor", path: ["proactive"] },
+	},
+	{
+		id: "doctor.timeoutMs",
+		group: "diagnostics",
+		label: "Probe timeout",
+		description: "How long one doctor probe may take, in milliseconds; 100 to 30000.",
+		source: "bytefly",
+		kind: "text",
+		fallback: String(DEFAULT_DOCTOR_CONFIG.timeoutMs),
+		json: "number",
+		options: [],
+		text: integerRule(100, 30_000),
+		config: { section: "doctor", path: ["timeoutMs"] },
+	},
+	{
+		id: "price.currency.code",
+		group: "pricing",
+		label: "Currency",
+		description:
+			"CNY prices DeepSeek from its yuan rates; USD from its published dollars, falling back to Pi's recorded cost.",
+		source: "bytefly",
+		kind: "enum",
+		fallback: DEFAULT_CURRENCY.code,
+		options: [
+			{ value: "CNY", label: "CNY (¥)" },
+			{ value: "USD", label: "USD ($)" },
+		],
+		config: { section: "price", path: ["currency", "code"] },
+		// Choosing a currency also sets its default precision, so the screen and the
+		// footer agree; the precision stays overridable afterwards.
+		also: (raw) => {
+			const currency = CURRENCY_DEFAULTS[raw as CurrencyCode];
+			return currency === undefined
+				? []
+				: [{ section: "price", path: ["currency", "decimals"], value: currency.decimals }];
+		},
+	},
+	{
+		id: "price.currency.decimals",
+		group: "pricing",
+		label: "Cost decimals",
+		description: "Digits shown after the decimal point in the footer's cost total.",
+		source: "bytefly",
+		kind: "enum",
+		fallback: "2",
+		json: "number",
+		options: DECIMALS_OPTIONS,
+		config: { section: "price", path: ["currency", "decimals"] },
 	},
 	{
 		id: "chrome.rail",
 		group: "transcript",
 		label: "Rail glyph",
-		description: "The single-column glyph that leads a tool result or notice body.",
+		description: "The single-column glyph that leads a tool result or notice body, e.g. ╎ │ ┃ ▏.",
 		source: "bytefly",
-		kind: "enum",
+		kind: "text",
 		fallback: GLYPHS.divider,
-		options: RAIL_OPTIONS,
-		config: { section: "chrome", key: "rail" },
+		options: [],
+		text: RAIL_RULE,
+		config: { section: "chrome", path: ["rail"] },
 	},
 	{
 		id: "outputPad",
@@ -145,6 +359,7 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		source: "app",
 		kind: "enum",
 		fallback: "1",
+		json: "number",
 		options: [
 			{ value: "0", label: "0" },
 			{ value: "1", label: "1" },
@@ -158,6 +373,7 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		source: "app",
 		kind: "boolean",
 		fallback: "false",
+		json: "boolean",
 		options: ON_OFF,
 	},
 ];
@@ -177,6 +393,21 @@ export function validValue(row: SettingDescriptor, raw: string): boolean {
 	return row.options.some((option) => option.value === raw);
 }
 
+/**
+ * Why a text row cannot store `raw`, or `undefined` when it can.
+ *
+ * The limits mirror the loaders (`notify.title` is sliced to 40, the currency
+ * symbol to 4) so the editor cannot save a value the next read shortens.
+ */
+export function textError(row: SettingDescriptor, raw: string): string | undefined {
+	const rule = row.text;
+	if (!rule) return `${row.label} is not a text setting.`;
+	if (raw.length > rule.maxLength) {
+		return `Too long: ${raw.length} characters, the limit is ${rule.maxLength}.`;
+	}
+	return rule.validate?.(raw);
+}
+
 /** The display label for `raw`, or the raw value when it is a valid custom one. */
 function labelFor(row: SettingDescriptor, raw: string): string {
 	return row.options.find((option) => option.value === raw)?.label ?? raw;
@@ -204,15 +435,35 @@ function appValue(snapshot: SettingsSnapshot, row: SettingDescriptor): { value:
 	}
 }
 
-/** Whether a project section sets `key`, so the origin is truthful. */
+/** Whether a document states this row's leaf, so the origin is truthful. */
+function statesConfig(config: SettingConfig, document: Record<string, unknown>): boolean {
+	return configValueAt(document, [config.section, ...config.path]) !== undefined;
+}
+
+/** Where the effective value came from: the project file, the personal one, or nothing. */
 function originFor(config: SettingConfig, snapshot: SettingsSnapshot, scope: WriteScope): SettingOrigin {
-	const globalRaw = configSection(snapshot.global, config.section);
-	const projectRaw = scope === "project" ? configSection(snapshot.project, config.section) : undefined;
-	if (projectRaw && config.key in projectRaw) return "project";
-	if (scope === "project") return "inherited";
-	return globalRaw && config.key in globalRaw ? "global" : "default";
+	if (scope === "project") return statesConfig(config, snapshot.project) ? "project" : "inherited";
+	return statesConfig(config, snapshot.global) ? "global" : "default";
 }
 
+/** Read one leaf of a `bytefly.json` section: project over global over defaults. */
+type SectionReader = (
+	globalRaw: Record<string, unknown> | undefined,
+	projectRaw: Record<string, unknown> | undefined,
+	path: readonly string[],
+) => unknown;
+
+const SECTION_READERS: Record<ConfigSectionName, SectionReader> = {
+	notify: (globalRaw, projectRaw, path) =>
+		configValueAt(normalizeNotifyConfig(projectRaw, normalizeNotifyConfig(globalRaw, DEFAULT_NOTIFY_CONFIG)), path),
+	chrome: (globalRaw, projectRaw, path) =>
+		configValueAt(normalizeChromeConfig(projectRaw, normalizeChromeConfig(globalRaw, DEFAULT_CHROME_CONFIG)), path),
+	doctor: (globalRaw, projectRaw, path) =>
+		configValueAt(normalizeDoctorConfig(projectRaw, normalizeDoctorConfig(globalRaw, DEFAULT_DOCTOR_CONFIG)), path),
+	price: (globalRaw, projectRaw, path) =>
+		configValueAt(normalizeByteflyConfig(projectRaw, normalizeByteflyConfig(globalRaw, DEFAULT_BYTEFLY_CONFIG)), path),
+};
+
 /** Read a `bytefly.json` preference, normalized over the global section. */
 function byteflyValue(
 	snapshot: SettingsSnapshot,
@@ -223,15 +474,11 @@ function byteflyValue(
 	if (!config) throw new Error(`Setting ${row.id} has no config section`);
 	const globalRaw = configSection(snapshot.global, config.section);
 	const projectRaw = scope === "project" ? configSection(snapshot.project, config.section) : undefined;
-	const origin = originFor(config, snapshot, scope);
-	if (config.section === "notify") {
-		const global = normalizeNotifyConfig(globalRaw, DEFAULT_NOTIFY_CONFIG);
-		const effective = normalizeNotifyConfig(projectRaw, global);
-		return { value: effective.enabled ? "true" : "false", origin };
-	}
-	const global = normalizeChromeConfig(globalRaw, DEFAULT_CHROME_CONFIG);
-	const effective = normalizeChromeConfig(projectRaw, global);
-	return { value: effective.rail, origin };
+	const leaf = SECTION_READERS[config.section](globalRaw, projectRaw, config.path);
+	return {
+		value: leaf === undefined ? row.fallback : String(leaf),
+		origin: originFor(config, snapshot, scope),
+	};
 }
 
 /** Build the rows for `scope` from a snapshot. */
@@ -244,23 +491,21 @@ export function settingViews(snapshot: SettingsSnapshot, scope: WriteScope): Set
 
 /** The next curated value, wrapping; an uncurated value starts the cycle. */
 export function nextValue(row: SettingDescriptor, current: string): SettingOption {
+	// A text row has no cycle: the value it holds is the value it keeps.
+	if (row.options.length === 0) return { value: current, label: current };
 	const index = row.options.findIndex((option) => option.value === current);
 	return row.options[(index + 1) % row.options.length] as SettingOption;
 }
 
-/** The JSON value a raw option stores, per row. */
+/** The JSON value a raw option stores, per the row's declared JSON type. */
 export function storedValue(row: SettingDescriptor, raw: string): unknown {
-	switch (row.id) {
-		case "outputPad":
-			return raw === "1" ? 1 : 0;
-		case "byteflyUi":
-		case "notify.enabled":
-		case "showHardwareCursor":
+	switch (row.json) {
+		case "boolean":
 			return raw === "true";
-		case "chrome.rail":
-			return raw;
+		case "number":
+			return Number(raw);
 		default:
-			throw new Error(`Unknown setting ${row.id}`);
+			return raw;
 	}
 }
 

package/extensions/bytefly/panel/tui/entries.ts

@@ -0,0 +1,58 @@
+/**
+ * The panel's entry model: a flat list where group headers and selectable rows
+ * interleave, shared by both sections.
+ *
+ * Pure: the list is rebuilt from a model or a set of views, and navigation is
+ * index arithmetic, so the component only has to keep one cursor per section.
+ */
+
+import { groupViews, type SettingView } from "../settings.ts";
+import type { PanelModel, PanelRow } from "../types.ts";
+
+/** A flat display entry: a group header or a selectable row. */
+export type PanelEntry =
+	| { kind: "group"; key: string; label: string; count: number }
+	| { kind: "row"; row: PanelRow }
+	| { kind: "setting"; setting: SettingView };
+
+/** A selectable entry's stable key, or `undefined` for a group header. */
+export function entryKey(entry: PanelEntry | undefined): string | undefined {
+	if (entry?.kind === "row") return entry.row.key;
+	if (entry?.kind === "setting") return entry.setting.id;
+	return undefined;
+}
+
+/** Whether an entry can take the focus. */
+export function isSelectable(entry: PanelEntry | undefined): boolean {
+	return entryKey(entry) !== undefined;
+}
+
+/** The next selectable entry from `from` in `direction`, or `undefined`. */
+export function nextRow(entries: PanelEntry[], from: number, direction: -1 | 1): number | undefined {
+	for (let index = from + direction; index >= 0 && index < entries.length; index += direction) {
+		if (isSelectable(entries[index])) return index;
+	}
+	return undefined;
+}
+
+/** Interleave the extension model's groups and rows into one display list. */
+export function entriesOf(model: PanelModel): PanelEntry[] {
+	const entries: PanelEntry[] = [];
+	for (const group of model.groups) {
+		entries.push({ kind: "group", key: group.key, label: group.label, count: group.count });
+		for (const row of model.rows) {
+			if (row.group === group.key) entries.push({ kind: "row", row });
+		}
+	}
+	return entries;
+}
+
+/** Interleave the settings views into the same group/row display list. */
+export function settingEntries(views: readonly SettingView[]): PanelEntry[] {
+	const entries: PanelEntry[] = [];
+	for (const group of groupViews(views)) {
+		entries.push({ kind: "group", key: group.key, label: group.label, count: group.views.length });
+		for (const view of group.views) entries.push({ kind: "setting", setting: view });
+	}
+	return entries;
+}