qwerty-cli 0.0.1-alpha.0 → 0.0.1-alpha.5

package/dist/cli.js

@@ -1,6 +1,67 @@
 // src/cli.ts
 import { Command as Command6 } from "commander";
 
+// package.json
+var package_default = {
+  name: "qwerty-cli",
+  version: "0.0.1-alpha.5",
+  description: "Terminal clone of qwerty-learner: typing practice for English vocabulary, with chapters, dictation, mistake book, and audio.",
+  type: "module",
+  bin: {
+    qwerty: "bin/qwerty.mjs"
+  },
+  files: [
+    "dist",
+    "bin",
+    "assets"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "sync-registry": "tsx scripts/sync-registry.ts",
+    prepublishOnly: "pnpm build"
+  },
+  engines: {
+    node: ">=20"
+  },
+  keywords: [
+    "qwerty",
+    "typing",
+    "cli",
+    "vocabulary",
+    "ink",
+    "terminal"
+  ],
+  license: "MIT",
+  dependencies: {
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    ink: "^5.0.1",
+    "ink-big-text": "^2.0.0",
+    "p-queue": "^8.0.1",
+    react: "^18.3.1",
+    undici: "^6.19.8",
+    zod: "^3.23.8"
+  },
+  devDependencies: {
+    "@types/node": "^20.14.10",
+    "@types/react": "^18.3.3",
+    "ts-morph": "^23.0.0",
+    tsup: "^8.2.4",
+    tsx: "^4.19.0",
+    typescript: "^5.5.4",
+    vitest: "^2.0.5"
+  },
+  pnpm: {
+    onlyBuiltDependencies: [
+      "esbuild"
+    ]
+  }
+};
+
 // src/commands/config.ts
 import { Command } from "commander";
 import chalk from "chalk";
@@ -449,6 +510,396 @@ import chalk3 from "chalk";
 import { render } from "ink";
 import { createElement } from "react";
 
+// src/ui/App.tsx
+import { useApp as useApp4, useInput as useInput8 } from "ink";
+
+// src/ui/nav.tsx
+import { createContext, useContext, useState, useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+var NavContext = createContext(null);
+function NavProvider({ initial, children }) {
+  const [stack, setStack] = useState([initial]);
+  const navigate = useCallback((frame) => {
+    setStack((s) => [...s, frame]);
+  }, []);
+  const replace = useCallback((frame) => {
+    setStack((s) => s.length === 0 ? [frame] : [...s.slice(0, -1), frame]);
+  }, []);
+  const back = useCallback(() => {
+    setStack((s) => s.length > 1 ? s.slice(0, -1) : s);
+  }, []);
+  const reset = useCallback((frame) => {
+    setStack([frame]);
+  }, []);
+  const current = stack[stack.length - 1];
+  return /* @__PURE__ */ jsx(NavContext.Provider, { value: { current, stack, navigate, replace, back, reset }, children });
+}
+function useNav() {
+  const ctx = useContext(NavContext);
+  if (!ctx) throw new Error("useNav must be used inside NavProvider");
+  return ctx;
+}
+
+// src/ui/Fullscreen.tsx
+import { useEffect } from "react";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var ENTER = "\x1B[?1049h\x1B[?25l";
+var LEAVE = "\x1B[?25h\x1B[?1049l";
+function shouldUse() {
+  return Boolean(process.stdout.isTTY) && process.env.QWERTY_NO_ALTSCREEN !== "1";
+}
+function Fullscreen({ children }) {
+  useEffect(() => {
+    if (!shouldUse()) return;
+    process.stdout.write(ENTER);
+    const leave = () => {
+      try {
+        process.stdout.write(LEAVE);
+      } catch {
+      }
+    };
+    const onSignal = () => {
+      leave();
+      process.exit(130);
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    process.once("exit", leave);
+    return () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      process.off("exit", leave);
+      leave();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx2(Fragment, { children });
+}
+
+// src/ui/audio-context.tsx
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/infra/audio.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { request as request2 } from "undici";
+import PQueue from "p-queue";
+var CANDIDATES = [
+  { kind: "afplay", cmd: "afplay", args: (f) => [f], supports: "both" },
+  { kind: "ffplay", cmd: "ffplay", args: (f) => ["-nodisp", "-autoexit", "-loglevel", "quiet", f], supports: "both" },
+  { kind: "mpg123", cmd: "mpg123", args: (f) => ["-q", f], supports: "mp3" },
+  { kind: "paplay", cmd: "paplay", args: (f) => [f], supports: "wav" },
+  { kind: "aplay", cmd: "aplay", args: (f) => ["-q", f], supports: "wav" },
+  {
+    kind: "powershell",
+    cmd: "powershell",
+    args: (f) => ["-NoProfile", "-Command", `(New-Object Media.SoundPlayer '${f}').PlaySync();`],
+    supports: "wav"
+  }
+];
+var PRON_API = "https://dict.youdao.com/dictvoice?audio=";
+var runtime = null;
+async function isExecutable(cmd) {
+  return new Promise((resolve2) => {
+    const probe = spawn(cmd, ["--version"], { stdio: "ignore" });
+    probe.on("error", () => resolve2(false));
+    probe.on("exit", () => resolve2(true));
+    setTimeout(() => {
+      probe.kill();
+      resolve2(false);
+    }, 500);
+  });
+}
+async function detect() {
+  let wav = null;
+  let mp3 = null;
+  for (const p of CANDIDATES) {
+    if (!await isExecutable(p.cmd)) continue;
+    if (!wav && (p.supports === "wav" || p.supports === "both")) wav = p;
+    if (!mp3 && (p.supports === "mp3" || p.supports === "both")) mp3 = p;
+    if (wav && mp3) break;
+  }
+  return { wav, mp3 };
+}
+async function initAudio(disabledByConfig) {
+  if (runtime) return runtime;
+  if (disabledByConfig) {
+    runtime = {
+      disabled: true,
+      wavPlayer: null,
+      mp3Player: null,
+      warning: null,
+      keyQueue: new PQueue({ concurrency: 1 }),
+      feedbackQueue: new PQueue({ concurrency: 1 }),
+      pronQueue: new PQueue({ concurrency: 1 })
+    };
+    return runtime;
+  }
+  const { wav, mp3 } = await detect();
+  let warning = null;
+  if (!wav && !mp3) {
+    warning = "No audio player found on PATH (looked for afplay/ffplay/mpg123/paplay/aplay/powershell). Sounds disabled.";
+  } else if (!mp3) {
+    warning = "No MP3 player found; word pronunciations will be skipped.";
+  }
+  runtime = {
+    disabled: !wav && !mp3,
+    wavPlayer: wav,
+    mp3Player: mp3,
+    warning,
+    keyQueue: new PQueue({ concurrency: 2 }),
+    feedbackQueue: new PQueue({ concurrency: 1 }),
+    pronQueue: new PQueue({ concurrency: 1 })
+  };
+  return runtime;
+}
+function spawnPlay(player, file) {
+  try {
+    const child = spawn(player.cmd, player.args(file), {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function playFile(file, kind) {
+  if (!runtime || runtime.disabled) return;
+  const player = kind === "wav" ? runtime.wavPlayer : runtime.mp3Player;
+  if (!player) return;
+  spawnPlay(player, file);
+}
+function playKeystroke() {
+  if (!runtime || runtime.disabled) return;
+  if (runtime.keyQueue.size >= 2) return;
+  void runtime.keyQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "key-default.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 30));
+  });
+}
+function playCorrect() {
+  if (!runtime || runtime.disabled) return;
+  void runtime.feedbackQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "correct.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 50));
+  });
+}
+function playWrong() {
+  if (!runtime || runtime.disabled) return;
+  void runtime.feedbackQueue.add(async () => {
+    playFile(join3(packageAssetsDir(), "sounds", "wrong.wav"), "wav");
+    await new Promise((r) => setTimeout(r, 50));
+  });
+}
+async function downloadPronunciation(word, accent) {
+  const cacheFile = paths.audioCache(word, accent);
+  if (await exists(cacheFile)) return cacheFile;
+  await mkdir3(dirname2(cacheFile), { recursive: true });
+  const type = accent === "us" ? 2 : 1;
+  const url = `${PRON_API}${encodeURIComponent(word)}&type=${type}`;
+  try {
+    const res = await request2(url, { headersTimeout: 8e3, bodyTimeout: 2e4 });
+    if (res.statusCode >= 400) return null;
+    const buf = Buffer.from(await res.body.arrayBuffer());
+    if (buf.length < 1024) return null;
+    const tmp = `${cacheFile}.tmp`;
+    await writeFile2(tmp, buf);
+    await rename2(tmp, cacheFile);
+    return cacheFile;
+  } catch {
+    return null;
+  }
+}
+async function playPronunciation(word, accent) {
+  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
+  await ensureDirs();
+  await runtime.pronQueue.add(async () => {
+    const file = await downloadPronunciation(word, accent);
+    if (file) playFile(file, "mp3");
+  });
+}
+async function prefetchPronunciation(word, accent) {
+  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
+  await ensureDirs();
+  void runtime.pronQueue.add(async () => {
+    await downloadPronunciation(word, accent);
+  });
+}
+function audioWarning() {
+  return runtime?.warning ?? null;
+}
+
+// src/ui/audio-context.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var AudioStatusContext = createContext2({ warning: null, ready: false });
+function AudioStatusProvider({
+  disabled,
+  children
+}) {
+  const [status, setStatus] = useState2({ warning: null, ready: false });
+  useEffect2(() => {
+    let cancelled = false;
+    initAudio(disabled).then(() => {
+      if (cancelled) return;
+      setStatus({ warning: audioWarning(), ready: true });
+    }).catch(() => {
+      if (cancelled) return;
+      setStatus({ warning: null, ready: true });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [disabled]);
+  return /* @__PURE__ */ jsx3(AudioStatusContext.Provider, { value: status, children });
+}
+function useAudioStatus() {
+  return useContext2(AudioStatusContext);
+}
+
+// src/ui/app-state.tsx
+import { createContext as createContext3, useCallback as useCallback2, useContext as useContext3, useState as useState3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var AppStateContext = createContext3(null);
+function AppStateProvider({
+  initialCfg,
+  children
+}) {
+  const [cfg, setCfgState] = useState3(initialCfg);
+  const setCfg = useCallback2(async (next) => {
+    setCfgState(next);
+    await saveConfig(next);
+  }, []);
+  return /* @__PURE__ */ jsx4(AppStateContext.Provider, { value: { cfg, setCfg }, children });
+}
+function useAppState() {
+  const ctx = useContext3(AppStateContext);
+  if (!ctx) throw new Error("useAppState must be used inside AppStateProvider");
+  return ctx;
+}
+
+// src/ui/screens/MainMenu.tsx
+import { useState as useState4 } from "react";
+import { Box as Box2, Text as Text2, useApp, useInput } from "ink";
+
+// src/ui/components/BigWord.tsx
+import { Box, Text, useStdout } from "ink";
+import BigText from "ink-big-text";
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+var PALETTE = {
+  accent: "#5eead4",
+  muted: "#6b7280",
+  text: "#e5e7eb",
+  primary: "#7dcfff",
+  success: "#86efac",
+  warning: "#fbbf24",
+  error: "#f87171"
+};
+function BigWord({ target, typed, error = false, hideTarget = false }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const chars = [...target];
+  const typedChars = [...typed];
+  const useBig = cols >= 60 && process.env.QWERTY_NO_BIGTEXT !== "1";
+  if (!useBig) {
+    return /* @__PURE__ */ jsx5(Box, { justifyContent: "center", children: chars.map((ch, i) => {
+      const isTyped = i < typedChars.length;
+      const display = hideTarget && !isTyped ? "_" : isTyped ? typedChars[i] : ch;
+      const color = isTyped ? PALETTE.accent : error ? PALETTE.error : PALETTE.muted;
+      return /* @__PURE__ */ jsxs(Text, { bold: isTyped, color, underline: !isTyped && error, children: [
+        display,
+        " "
+      ] }, i);
+    }) });
+  }
+  return /* @__PURE__ */ jsx5(Box, { justifyContent: "center", flexDirection: "row", children: chars.map((ch, i) => {
+    const isTyped = i < typedChars.length;
+    const display = hideTarget && !isTyped ? "_" : isTyped ? typedChars[i] : ch;
+    const color = isTyped ? PALETTE.accent : error ? PALETTE.error : PALETTE.muted;
+    return /* @__PURE__ */ jsx5(BigText, { text: display, font: "tiny", colors: [color], space: false }, i);
+  }) });
+}
+
+// src/ui/screens/MainMenu.tsx
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+function MainMenu({ cfg }) {
+  const [selected, setSelected] = useState4(0);
+  const { exit } = useApp();
+  const nav = useNav();
+  const audio = useAudioStatus();
+  const items = [
+    {
+      key: "p",
+      label: "Practice",
+      hint: cfg.defaultDict ? `start ${cfg.defaultDict}` : "pick a dictionary",
+      run: () => {
+        if (cfg.defaultDict) {
+          nav.navigate({
+            name: "practice",
+            params: { dictId: cfg.defaultDict, chapterIndex: 0, mode: cfg.defaultMode }
+          });
+        } else {
+          nav.navigate({ name: "dict", params: { pickerMode: "choose-then-practice" } });
+        }
+      }
+    },
+    { key: "d", label: "Dictionaries", hint: "browse, pull, set default", run: () => nav.navigate({ name: "dict" }) },
+    { key: "w", label: "Word lookup", hint: "search local dicts", run: () => nav.navigate({ name: "word" }) },
+    { key: "s", label: "Stats", hint: "history & trends", run: () => nav.navigate({ name: "stats" }) },
+    { key: "c", label: "Config", hint: "edit preferences", run: () => nav.navigate({ name: "config" }) },
+    { key: "q", label: "Quit", hint: "Ctrl+C also exits", run: () => exit() }
+  ];
+  useInput((input, key) => {
+    if (key.upArrow) setSelected((i) => (i - 1 + items.length) % items.length);
+    if (key.downArrow) setSelected((i) => (i + 1) % items.length);
+    if (key.return) {
+      items[selected].run();
+      return;
+    }
+    for (const it of items) {
+      if (input === it.key) {
+        it.run();
+        return;
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx6(Text2, { bold: true, color: PALETTE.accent, children: "qwerty" }),
+      /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: "  \xB7  typing practice for the terminal" })
+    ] }),
+    /* @__PURE__ */ jsx6(Box2, { marginTop: 2, flexDirection: "column", children: items.map((it, i) => {
+      const active = i === selected;
+      return /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx6(Text2, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+        /* @__PURE__ */ jsxs2(Text2, { color: active ? PALETTE.accent : PALETTE.muted, children: [
+          "[",
+          it.key,
+          "]"
+        ] }),
+        /* @__PURE__ */ jsx6(Text2, { children: " " }),
+        /* @__PURE__ */ jsx6(Text2, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: it.label.padEnd(14) }),
+        /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: it.hint })
+      ] }, it.key);
+    }) }),
+    /* @__PURE__ */ jsx6(Box2, { marginTop: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.muted, children: [
+      "default dict: ",
+      cfg.defaultDict ?? "(none \u2014 pick one in Dictionaries)"
+    ] }) }),
+    /* @__PURE__ */ jsx6(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: "\u2191/\u2193 navigate  \xB7  Enter select  \xB7  letters jump" }) }),
+    audio.warning && /* @__PURE__ */ jsx6(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.warning, children: [
+      "! ",
+      audio.warning
+    ] }) })
+  ] });
+}
+
+// src/ui/screens/PracticeScreen.tsx
+import { useState as useState6, useEffect as useEffect5, useRef as useRef3 } from "react";
+import { Box as Box3, Text as Text3, useApp as useApp3, useInput as useInput3 } from "ink";
+import BigText2 from "ink-big-text";
+
 // src/util/shuffle.ts
 function shuffle(arr, rng = Math.random) {
   const out = [...arr];
@@ -479,9 +930,6 @@ function chunkChapters(words, chapterSize) {
   }
   return chunks;
 }
-function chapterCount(totalWords, chapterSize) {
-  return Math.ceil(totalWords / chapterSize);
-}
 function buildPlaylist(chapter, mode, seed) {
   if (mode === "random") {
     const rng = seed === void 0 ? Math.random : mulberry32(seed);
@@ -490,160 +938,33 @@ function buildPlaylist(chapter, mode, seed) {
   return chapter;
 }
 
-// src/domain/stats.ts
-import { z as z3 } from "zod";
-var SessionRecordSchema = z3.object({
-  ts: z3.string(),
-  dictId: z3.string(),
-  chapter: z3.number().int().nonnegative(),
-  mode: z3.string(),
-  wordCount: z3.number().int().nonnegative(),
-  errors: z3.number().int().nonnegative(),
-  durationMs: z3.number().int().nonnegative(),
-  perWordErrors: z3.record(z3.string(), z3.number().int().nonnegative()).default({})
-});
-async function appendSession(record) {
-  await appendJsonl(paths.stats, record);
-}
-async function loadSessions() {
-  const rows = await readJsonl(paths.stats);
-  return rows.map((r) => SessionRecordSchema.safeParse(r)).filter((r) => r.success).map((r) => r.data);
-}
-function computeWPM(record) {
-  if (record.durationMs === 0) return 0;
-  const minutes = record.durationMs / 6e4;
-  return Math.round(record.wordCount / minutes * 10) / 10;
+// src/domain/input-buffer.ts
+function initialState(target) {
+  return { target, typed: "", errorsThisWord: 0 };
 }
-function accuracy(record) {
-  if (record.wordCount === 0) return 1;
-  const wordsWithErrors = Object.keys(record.perWordErrors).length;
-  return Math.max(0, Math.min(1, (record.wordCount - wordsWithErrors) / record.wordCount));
-}
-function dailyStreak(sessions, now = /* @__PURE__ */ new Date()) {
-  if (sessions.length === 0) return 0;
-  const days = /* @__PURE__ */ new Set();
-  for (const s of sessions) days.add(s.ts.slice(0, 10));
-  let streak = 0;
-  const cur = new Date(now);
-  while (true) {
-    const key = cur.toISOString().slice(0, 10);
-    if (!days.has(key)) break;
-    streak++;
-    cur.setUTCDate(cur.getUTCDate() - 1);
-  }
-  return streak;
-}
-var SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
-function sparkline(values) {
-  if (values.length === 0) return "";
-  const max = Math.max(...values, 1);
-  const min = Math.min(...values, 0);
-  const range = Math.max(1, max - min);
-  return values.map((v) => {
-    const idx = Math.floor((v - min) / range * (SPARK.length - 1));
-    return SPARK[Math.max(0, Math.min(SPARK.length - 1, idx))];
-  }).join("");
-}
-function dailyBuckets(sessions, days, now = /* @__PURE__ */ new Date()) {
-  const out = [];
-  const byDay = /* @__PURE__ */ new Map();
-  for (const s of sessions) {
-    const key = s.ts.slice(0, 10);
-    const arr = byDay.get(key) ?? [];
-    arr.push(s);
-    byDay.set(key, arr);
-  }
-  const cur = new Date(now);
-  cur.setUTCDate(cur.getUTCDate() - (days - 1));
-  for (let i = 0; i < days; i++) {
-    const key = cur.toISOString().slice(0, 10);
-    const todays = byDay.get(key) ?? [];
-    if (todays.length === 0) {
-      out.push({ date: key, wpm: 0, accuracy: 0, sessions: 0 });
-    } else {
-      const wpm = todays.reduce((a, s) => a + computeWPM(s), 0) / todays.length;
-      const acc = todays.reduce((a, s) => a + accuracy(s), 0) / todays.length;
-      out.push({ date: key, wpm, accuracy: acc, sessions: todays.length });
-    }
-    cur.setUTCDate(cur.getUTCDate() + 1);
-  }
-  return out;
-}
-
-// src/domain/mistakes.ts
-import { z as z4 } from "zod";
-var MistakeBookSchema = z4.record(
-  z4.string(),
-  z4.object({
-    count: z4.number().int().nonnegative(),
-    lastSeen: z4.string(),
-    dictIds: z4.array(z4.string()).default([])
-  })
-);
-async function loadMistakes() {
-  const raw = await readJson(paths.mistakes);
-  if (!raw) return {};
-  const parsed = MistakeBookSchema.safeParse(raw);
-  if (!parsed.success) {
-    console.warn("Mistake book is corrupt; starting fresh");
-    return {};
-  }
-  return parsed.data;
-}
-async function saveMistakes(book) {
-  await writeJsonAtomic(paths.mistakes, book);
-}
-function bump(book, word, dictId, delta = 1) {
-  const prev = book[word] ?? { count: 0, lastSeen: (/* @__PURE__ */ new Date(0)).toISOString(), dictIds: [] };
-  const dictIds = prev.dictIds.includes(dictId) ? prev.dictIds : [...prev.dictIds, dictId];
-  return {
-    ...book,
-    [word]: {
-      count: prev.count + delta,
-      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
-      dictIds
-    }
-  };
-}
-function topN(book, n) {
-  return Object.entries(book).sort((a, b) => b[1].count - a[1].count).slice(0, n);
-}
-
-// src/ui/screens/PracticeScreen.tsx
-import { useState as useState2, useEffect as useEffect3, useRef as useRef3 } from "react";
-import { Box as Box4, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
-
-// src/ui/hooks/useWordLoop.ts
-import { useEffect, useReducer, useRef, useState } from "react";
-import { useInput, useApp } from "ink";
-
-// src/domain/input-buffer.ts
-function initialState(target) {
-  return { target, typed: "", errorsThisWord: 0 };
-}
-function reduce(state, ev) {
-  switch (ev.type) {
-    case "reset":
-      return { state: { ...state, typed: "" }, effect: "none" };
-    case "backspace": {
-      if (state.typed.length === 0) return { state, effect: "none" };
-      return { state: { ...state, typed: state.typed.slice(0, -1) }, effect: "none" };
-    }
-    case "char": {
-      const candidate = state.typed + ev.ch;
-      const targetUpToCandidate = [...state.target].slice(0, [...candidate].length).join("");
-      if (candidate === targetUpToCandidate) {
-        if (candidate.length === state.target.length) {
-          return { state: { ...state, typed: candidate }, effect: "correct" };
-        }
-        return { state: { ...state, typed: candidate }, effect: "progress" };
-      }
-      return {
-        state: { ...state, typed: "", errorsThisWord: state.errorsThisWord + 1 },
-        effect: "wrong"
-      };
-    }
-  }
+function reduce(state, ev) {
+  switch (ev.type) {
+    case "reset":
+      return { state: { ...state, typed: "" }, effect: "none" };
+    case "backspace": {
+      if (state.typed.length === 0) return { state, effect: "none" };
+      return { state: { ...state, typed: state.typed.slice(0, -1) }, effect: "none" };
+    }
+    case "char": {
+      const candidate = state.typed + ev.ch;
+      const targetUpToCandidate = [...state.target].slice(0, [...candidate].length).join("");
+      if (candidate === targetUpToCandidate) {
+        if (candidate.length === state.target.length) {
+          return { state: { ...state, typed: candidate }, effect: "correct" };
+        }
+        return { state: { ...state, typed: candidate }, effect: "progress" };
+      }
+      return {
+        state: { ...state, typed: "", errorsThisWord: state.errorsThisWord + 1 },
+        effect: "wrong"
+      };
+    }
+  }
 }
 
 // src/domain/session.ts
@@ -697,6 +1018,35 @@ function feedSession(session, ev, now = Date.now()) {
     effect
   };
 }
+function skipSession(session, now = Date.now()) {
+  if (!session.current) return { session, effect: "none" };
+  const result = {
+    word: session.current.input.target,
+    errors: 0,
+    durationMs: now - session.current.wordStartedAt,
+    skipped: true
+  };
+  const nextIndex = session.current.wordIndex + 1;
+  const results = [...session.results, result];
+  if (nextIndex >= session.playlist.length) {
+    return {
+      session: { ...session, results, current: null, finishedAt: now },
+      effect: "skipped"
+    };
+  }
+  return {
+    session: {
+      ...session,
+      results,
+      current: {
+        wordIndex: nextIndex,
+        wordStartedAt: now,
+        input: initialState(session.playlist[nextIndex].name)
+      }
+    },
+    effect: "skipped"
+  };
+}
 function sessionSummary(session) {
   const errors = session.results.reduce((a, r) => a + r.errors, 0);
   const durationMs = (session.finishedAt ?? Date.now()) - session.startedAt;
@@ -707,11 +1057,56 @@ function sessionSummary(session) {
   return { wordCount: session.results.length, errors, durationMs, perWordErrors };
 }
 
+// src/domain/mistakes.ts
+import { z as z3 } from "zod";
+var MistakeBookSchema = z3.record(
+  z3.string(),
+  z3.object({
+    count: z3.number().int().nonnegative(),
+    lastSeen: z3.string(),
+    dictIds: z3.array(z3.string()).default([])
+  })
+);
+async function loadMistakes() {
+  const raw = await readJson(paths.mistakes);
+  if (!raw) return {};
+  const parsed = MistakeBookSchema.safeParse(raw);
+  if (!parsed.success) {
+    console.warn("Mistake book is corrupt; starting fresh");
+    return {};
+  }
+  return parsed.data;
+}
+async function saveMistakes(book) {
+  await writeJsonAtomic(paths.mistakes, book);
+}
+function bump(book, word, dictId, delta = 1) {
+  const prev = book[word] ?? { count: 0, lastSeen: (/* @__PURE__ */ new Date(0)).toISOString(), dictIds: [] };
+  const dictIds = prev.dictIds.includes(dictId) ? prev.dictIds : [...prev.dictIds, dictId];
+  return {
+    ...book,
+    [word]: {
+      count: prev.count + delta,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      dictIds
+    }
+  };
+}
+function topN(book, n) {
+  return Object.entries(book).sort((a, b) => b[1].count - a[1].count).slice(0, n);
+}
+
 // src/ui/hooks/useWordLoop.ts
+import { useEffect as useEffect3, useReducer, useRef, useState as useState5 } from "react";
+import { useInput as useInput2, useApp as useApp2 } from "ink";
 function reducer(state, action) {
   if (action.type === "start") {
     return { session: startSession(action.playlist, action.now), lastEffect: null };
   }
+  if (action.type === "skip") {
+    const r = skipSession(state.session, action.now);
+    return { session: r.session, lastEffect: r.effect };
+  }
   if (action.type === "event") {
     if (action.key.backspace || action.key.delete) {
       const r = feedSession(state.session, { type: "backspace" }, action.now);
@@ -730,20 +1125,25 @@ function reducer(state, action) {
   }
   return state;
 }
-function useWordLoop({ playlist, onComplete, onTab, onEscape, enabled = true }) {
+function useWordLoop({ playlist, onComplete, onTab, onEscape, onSkip, enabled = true }) {
   const [state, dispatch] = useReducer(reducer, void 0, () => ({
     session: startSession(playlist, Date.now()),
     lastEffect: null
   }));
   const completedRef = useRef(false);
-  const [tick, setTick] = useState(0);
-  const { exit } = useApp();
-  useInput(
+  const [tick, setTick] = useState5(0);
+  const { exit } = useApp2();
+  useInput2(
     (input, key) => {
       if (key.ctrl && input === "c") {
         exit();
         return;
       }
+      if (key.ctrl && input === "n") {
+        onSkip?.();
+        dispatch({ type: "skip", now: Date.now() });
+        return;
+      }
       if (key.escape) {
         onEscape?.();
         return;
@@ -763,13 +1163,13 @@ function useWordLoop({ playlist, onComplete, onTab, onEscape, enabled = true })
     },
     { isActive: enabled }
   );
-  useEffect(() => {
+  useEffect3(() => {
     if (state.session.finishedAt !== null && !completedRef.current) {
       completedRef.current = true;
       onComplete(state.session);
     }
   }, [state.session, onComplete]);
-  useEffect(() => {
+  useEffect3(() => {
     if (state.session.finishedAt !== null) return;
     const id = setInterval(() => setTick((t) => t + 1), 1e3);
     return () => clearInterval(id);
@@ -778,172 +1178,14 @@ function useWordLoop({ playlist, onComplete, onTab, onEscape, enabled = true })
 }
 
 // src/ui/hooks/useAudio.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-
-// src/infra/audio.ts
-import { spawn } from "child_process";
-import { mkdir as mkdir3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { join as join3, dirname as dirname2 } from "path";
-import { request as request2 } from "undici";
-import PQueue from "p-queue";
-var CANDIDATES = [
-  { kind: "afplay", cmd: "afplay", args: (f) => [f], supports: "both" },
-  { kind: "ffplay", cmd: "ffplay", args: (f) => ["-nodisp", "-autoexit", "-loglevel", "quiet", f], supports: "both" },
-  { kind: "mpg123", cmd: "mpg123", args: (f) => ["-q", f], supports: "mp3" },
-  { kind: "paplay", cmd: "paplay", args: (f) => [f], supports: "wav" },
-  { kind: "aplay", cmd: "aplay", args: (f) => ["-q", f], supports: "wav" },
-  {
-    kind: "powershell",
-    cmd: "powershell",
-    args: (f) => ["-NoProfile", "-Command", `(New-Object Media.SoundPlayer '${f}').PlaySync();`],
-    supports: "wav"
-  }
-];
-var PRON_API = "https://dict.youdao.com/dictvoice?audio=";
-var runtime = null;
-async function isExecutable(cmd) {
-  return new Promise((resolve2) => {
-    const probe = spawn(cmd, ["--version"], { stdio: "ignore" });
-    probe.on("error", () => resolve2(false));
-    probe.on("exit", () => resolve2(true));
-    setTimeout(() => {
-      probe.kill();
-      resolve2(false);
-    }, 500);
-  });
-}
-async function detect() {
-  let wav = null;
-  let mp3 = null;
-  for (const p of CANDIDATES) {
-    if (!await isExecutable(p.cmd)) continue;
-    if (!wav && (p.supports === "wav" || p.supports === "both")) wav = p;
-    if (!mp3 && (p.supports === "mp3" || p.supports === "both")) mp3 = p;
-    if (wav && mp3) break;
-  }
-  return { wav, mp3 };
-}
-async function initAudio(disabledByConfig) {
-  if (runtime) return runtime;
-  if (disabledByConfig) {
-    runtime = {
-      disabled: true,
-      wavPlayer: null,
-      mp3Player: null,
-      warning: null,
-      keyQueue: new PQueue({ concurrency: 1 }),
-      feedbackQueue: new PQueue({ concurrency: 1 }),
-      pronQueue: new PQueue({ concurrency: 1 })
-    };
-    return runtime;
-  }
-  const { wav, mp3 } = await detect();
-  let warning = null;
-  if (!wav && !mp3) {
-    warning = "No audio player found on PATH (looked for afplay/ffplay/mpg123/paplay/aplay/powershell). Sounds disabled.";
-  } else if (!mp3) {
-    warning = "No MP3 player found; word pronunciations will be skipped.";
-  }
-  runtime = {
-    disabled: !wav && !mp3,
-    wavPlayer: wav,
-    mp3Player: mp3,
-    warning,
-    keyQueue: new PQueue({ concurrency: 2 }),
-    feedbackQueue: new PQueue({ concurrency: 1 }),
-    pronQueue: new PQueue({ concurrency: 1 })
-  };
-  return runtime;
-}
-function spawnPlay(player, file) {
-  try {
-    const child = spawn(player.cmd, player.args(file), {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.on("error", () => {
-    });
-    child.unref();
-  } catch {
-  }
-}
-function playFile(file, kind) {
-  if (!runtime || runtime.disabled) return;
-  const player = kind === "wav" ? runtime.wavPlayer : runtime.mp3Player;
-  if (!player) return;
-  spawnPlay(player, file);
-}
-function playKeystroke() {
-  if (!runtime || runtime.disabled) return;
-  if (runtime.keyQueue.size >= 2) return;
-  void runtime.keyQueue.add(async () => {
-    playFile(join3(packageAssetsDir(), "sounds", "key-default.wav"), "wav");
-    await new Promise((r) => setTimeout(r, 30));
-  });
-}
-function playCorrect() {
-  if (!runtime || runtime.disabled) return;
-  void runtime.feedbackQueue.add(async () => {
-    playFile(join3(packageAssetsDir(), "sounds", "correct.wav"), "wav");
-    await new Promise((r) => setTimeout(r, 50));
-  });
-}
-function playWrong() {
-  if (!runtime || runtime.disabled) return;
-  void runtime.feedbackQueue.add(async () => {
-    playFile(join3(packageAssetsDir(), "sounds", "wrong.wav"), "wav");
-    await new Promise((r) => setTimeout(r, 50));
-  });
-}
-async function downloadPronunciation(word, accent) {
-  const cacheFile = paths.audioCache(word, accent);
-  if (await exists(cacheFile)) return cacheFile;
-  await mkdir3(dirname2(cacheFile), { recursive: true });
-  const type = accent === "us" ? 2 : 1;
-  const url = `${PRON_API}${encodeURIComponent(word)}&type=${type}`;
-  try {
-    const res = await request2(url, { headersTimeout: 8e3, bodyTimeout: 2e4 });
-    if (res.statusCode >= 400) return null;
-    const buf = Buffer.from(await res.body.arrayBuffer());
-    if (buf.length < 1024) return null;
-    const tmp = `${cacheFile}.tmp`;
-    await writeFile2(tmp, buf);
-    await rename2(tmp, cacheFile);
-    return cacheFile;
-  } catch {
-    return null;
-  }
-}
-async function playPronunciation(word, accent) {
-  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
-  await ensureDirs();
-  await runtime.pronQueue.add(async () => {
-    const file = await downloadPronunciation(word, accent);
-    if (file) playFile(file, "mp3");
-  });
-}
-async function prefetchPronunciation(word, accent) {
-  if (!runtime || runtime.disabled || !runtime.mp3Player) return;
-  await ensureDirs();
-  void runtime.pronQueue.add(async () => {
-    await downloadPronunciation(word, accent);
-  });
-}
-function audioWarning() {
-  return runtime?.warning ?? null;
-}
-
-// src/ui/hooks/useAudio.ts
+import { useEffect as useEffect4, useRef as useRef2 } from "react";
 function useAudio(opts) {
   const initedRef = useRef2(false);
-  useEffect2(() => {
+  useEffect4(() => {
     if (initedRef.current) return;
     initedRef.current = true;
-    initAudio(!opts.enabled).then(() => {
-      const w = audioWarning();
-      if (w) opts.onWarning?.(w);
-    }).catch(() => void 0);
-  }, [opts]);
+    initAudio(!opts.enabled).catch(() => void 0);
+  }, [opts.enabled]);
   return {
     keystroke: () => opts.enabled && playKeystroke(),
     correct: () => opts.enabled && playCorrect(),
@@ -959,267 +1201,1082 @@ function useAudio(opts) {
   };
 }
 
-// src/ui/components/WordInput.tsx
-import { Box, Text } from "ink";
-import { jsx } from "react/jsx-runtime";
-function WordInput({ state, hideTarget = false, flashError = false }) {
-  const target = [...state.target];
-  const typed = [...state.typed];
-  return /* @__PURE__ */ jsx(Box, { children: target.map((ch, i) => {
-    const t = typed[i];
-    if (t !== void 0) {
-      return /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: t }, i);
+// src/ui/hooks/useSessionPersistence.ts
+import { useCallback as useCallback3 } from "react";
+
+// src/domain/stats.ts
+import { z as z4 } from "zod";
+var SessionRecordSchema = z4.object({
+  ts: z4.string(),
+  dictId: z4.string(),
+  chapter: z4.number().int().nonnegative(),
+  mode: z4.string(),
+  wordCount: z4.number().int().nonnegative(),
+  errors: z4.number().int().nonnegative(),
+  durationMs: z4.number().int().nonnegative(),
+  perWordErrors: z4.record(z4.string(), z4.number().int().nonnegative()).default({})
+});
+async function appendSession(record) {
+  await appendJsonl(paths.stats, record);
+}
+async function loadSessions() {
+  const rows = await readJsonl(paths.stats);
+  return rows.map((r) => SessionRecordSchema.safeParse(r)).filter((r) => r.success).map((r) => r.data);
+}
+function computeWPM(record) {
+  if (record.durationMs === 0) return 0;
+  const minutes = record.durationMs / 6e4;
+  return Math.round(record.wordCount / minutes * 10) / 10;
+}
+function accuracy(record) {
+  if (record.wordCount === 0) return 1;
+  const wordsWithErrors = Object.keys(record.perWordErrors).length;
+  return Math.max(0, Math.min(1, (record.wordCount - wordsWithErrors) / record.wordCount));
+}
+function dailyStreak(sessions, now = /* @__PURE__ */ new Date()) {
+  if (sessions.length === 0) return 0;
+  const days = /* @__PURE__ */ new Set();
+  for (const s of sessions) days.add(s.ts.slice(0, 10));
+  let streak = 0;
+  const cur = new Date(now);
+  while (true) {
+    const key = cur.toISOString().slice(0, 10);
+    if (!days.has(key)) break;
+    streak++;
+    cur.setUTCDate(cur.getUTCDate() - 1);
+  }
+  return streak;
+}
+var SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function sparkline(values) {
+  if (values.length === 0) return "";
+  const max = Math.max(...values, 1);
+  const min = Math.min(...values, 0);
+  const range = Math.max(1, max - min);
+  return values.map((v) => {
+    const idx = Math.floor((v - min) / range * (SPARK.length - 1));
+    return SPARK[Math.max(0, Math.min(SPARK.length - 1, idx))];
+  }).join("");
+}
+function dailyBuckets(sessions, days, now = /* @__PURE__ */ new Date()) {
+  const out = [];
+  const byDay = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const key = s.ts.slice(0, 10);
+    const arr = byDay.get(key) ?? [];
+    arr.push(s);
+    byDay.set(key, arr);
+  }
+  const cur = new Date(now);
+  cur.setUTCDate(cur.getUTCDate() - (days - 1));
+  for (let i = 0; i < days; i++) {
+    const key = cur.toISOString().slice(0, 10);
+    const todays = byDay.get(key) ?? [];
+    if (todays.length === 0) {
+      out.push({ date: key, wpm: 0, accuracy: 0, sessions: 0 });
+    } else {
+      const wpm = todays.reduce((a, s) => a + computeWPM(s), 0) / todays.length;
+      const acc = todays.reduce((a, s) => a + accuracy(s), 0) / todays.length;
+      out.push({ date: key, wpm, accuracy: acc, sessions: todays.length });
+    }
+    cur.setUTCDate(cur.getUTCDate() + 1);
+  }
+  return out;
+}
+
+// src/ui/hooks/useSessionPersistence.ts
+function useSessionPersistence(meta) {
+  return useCallback3(
+    async (summary) => {
+      const rec = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        dictId: meta.dictId,
+        chapter: meta.chapterIndex,
+        mode: meta.mode,
+        wordCount: summary.wordCount,
+        errors: summary.errors,
+        durationMs: summary.durationMs,
+        perWordErrors: summary.perWordErrors
+      };
+      await appendSession(rec);
+      const dirty = Object.entries(summary.perWordErrors).filter(([, n]) => n > 0);
+      if (dirty.length === 0) return;
+      let book = await loadMistakes();
+      for (const [word, n] of dirty) book = bump(book, word, meta.dictId, n);
+      await saveMistakes(book);
+    },
+    [meta.dictId, meta.chapterIndex, meta.mode]
+  );
+}
+
+// src/ui/screens/PracticeScreen.tsx
+import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+function PracticeScreen({ params }) {
+  const { dictId, chapterIndex, mode } = params;
+  const { cfg } = useAppState();
+  const nav = useNav();
+  const [phase, setPhase] = useState6("loading");
+  const [loaded, setLoaded] = useState6(null);
+  const [errorMsg, setErrorMsg] = useState6(null);
+  useEffect5(() => {
+    let cancelled = false;
+    setPhase("loading");
+    setLoaded(null);
+    setErrorMsg(null);
+    (async () => {
+      try {
+        const words = await ensureDictionary(dictId);
+        if (cancelled) return;
+        if (mode === "review") {
+          const book = await loadMistakes();
+          if (cancelled) return;
+          const reviewWords = words.filter((w) => book[w.name]?.count).slice(0, cfg.chapterSize);
+          if (reviewWords.length === 0) {
+            setErrorMsg("No mistakes to review yet. Practice some chapters first.");
+            setPhase("error");
+            return;
+          }
+          setLoaded({ playlist: reviewWords, totalChapters: 1 });
+          setPhase("typing");
+          return;
+        }
+        const chapters = chunkChapters(words, cfg.chapterSize);
+        if (chapters.length === 0) {
+          setErrorMsg(`Dictionary ${dictId} is empty.`);
+          setPhase("error");
+          return;
+        }
+        const idx = Math.max(0, Math.min(chapters.length - 1, chapterIndex));
+        const playlist = buildPlaylist(chapters[idx], mode);
+        setLoaded({ playlist, totalChapters: chapters.length });
+        setPhase("typing");
+      } catch (err) {
+        if (cancelled) return;
+        setErrorMsg(err.message);
+        setPhase("error");
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [dictId, chapterIndex, mode, cfg.chapterSize]);
+  if (phase === "loading") {
+    return /* @__PURE__ */ jsx7(Centered, { text: "loading\u2026", color: PALETTE.muted });
+  }
+  if (phase === "error") {
+    return /* @__PURE__ */ jsx7(ErrorView, { msg: errorMsg ?? "Unknown error" });
+  }
+  if (!loaded) return null;
+  return /* @__PURE__ */ jsx7(
+    PracticeRunner,
+    {
+      params,
+      loaded,
+      phase,
+      setPhase
+    },
+    `${dictId}-${chapterIndex}-${mode}`
+  );
+}
+function PracticeRunner({
+  params,
+  loaded,
+  phase,
+  setPhase
+}) {
+  const { dictId, chapterIndex, mode } = params;
+  const { cfg } = useAppState();
+  const nav = useNav();
+  const { exit } = useApp3();
+  const goBack = () => nav.stack.length > 1 ? nav.back() : exit();
+  const persist = useSessionPersistence({ dictId, chapterIndex, mode });
+  const audio = useAudio({
+    enabled: cfg.sounds.master,
+    accent: cfg.accent,
+    autoplayPronunciation: cfg.autoplayPronunciation
+  });
+  const finishedRef = useRef3(false);
+  const lastEffectRef = useRef3(null);
+  const lastIndexRef = useRef3(-1);
+  const { session, lastEffect, tick } = useWordLoop({
+    playlist: loaded.playlist,
+    enabled: phase === "typing",
+    onComplete: (s) => {
+      if (finishedRef.current) return;
+      finishedRef.current = true;
+      setPhase("summary");
+      Promise.resolve(persist(sessionSummary(s))).catch((err) => {
+        console.error("Failed to persist session:", err);
+      });
+    },
+    onEscape: () => setPhase(phase === "paused" ? "typing" : "paused"),
+    onTab: () => {
+      const cur = session.current ? loaded.playlist[session.current.wordIndex] : void 0;
+      if (cur) void audio.pronounce(cur.name);
     }
-    if (hideTarget) {
-      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "_" }, i);
+  });
+  useEffect5(() => {
+    if (lastEffect === null) return;
+    if (lastEffect === lastEffectRef.current) return;
+    lastEffectRef.current = lastEffect;
+    if (lastEffect === "wrong" && cfg.sounds.feedback) audio.wrong();
+    if (lastEffect === "progress" && cfg.sounds.keystroke) audio.keystroke();
+    if (lastEffect === "correct") {
+      if (cfg.sounds.feedback) audio.correct();
+      if (cfg.sounds.keystroke) audio.keystroke();
     }
-    return /* @__PURE__ */ jsx(Text, { dimColor: true, underline: true, color: flashError ? "red" : void 0, children: ch }, i);
-  }) });
+  }, [lastEffect, audio, cfg.sounds.feedback, cfg.sounds.keystroke]);
+  useEffect5(() => {
+    const idx = session.current?.wordIndex ?? -1;
+    if (idx === -1) return;
+    if (idx === lastIndexRef.current) return;
+    lastIndexRef.current = idx;
+    const cur = loaded.playlist[idx];
+    const next = loaded.playlist[idx + 1];
+    if (cur && cfg.autoplayPronunciation) audio.pronounce(cur.name);
+    if (next) audio.prefetch(next.name);
+  }, [session.current?.wordIndex, audio, cfg.autoplayPronunciation, loaded.playlist]);
+  void tick;
+  useInput3(
+    (input) => {
+      if (input === "r") setPhase("typing");
+      if (input === "q") goBack();
+    },
+    { isActive: phase === "paused" }
+  );
+  useInput3(
+    (input) => {
+      if (input === "q") {
+        goBack();
+        return;
+      }
+      if (input === "n") {
+        const nextIdx = chapterIndex + 1;
+        if (mode === "loop") {
+          nav.replace({ name: "practice", params: { dictId, chapterIndex, mode } });
+        } else if (mode === "review" || nextIdx >= loaded.totalChapters) {
+          goBack();
+        } else {
+          nav.replace({ name: "practice", params: { dictId, chapterIndex: nextIdx, mode } });
+        }
+        return;
+      }
+      if (input === "m") {
+        nav.replace({ name: "practice", params: { dictId, chapterIndex: 0, mode: "review" } });
+        return;
+      }
+    },
+    { isActive: phase === "summary" }
+  );
+  if (phase === "paused") return /* @__PURE__ */ jsx7(PausedView, {});
+  if (phase === "summary") {
+    return /* @__PURE__ */ jsx7(
+      SummaryView,
+      {
+        dictId,
+        chapterIndex,
+        totalChapters: loaded.totalChapters,
+        mode,
+        summary: sessionSummary(session)
+      }
+    );
+  }
+  const currentWord = session.current ? loaded.playlist[session.current.wordIndex] : loaded.playlist[loaded.playlist.length - 1];
+  const inputState = session.current?.input ?? { target: "", typed: "", errorsThisWord: 0 };
+  const elapsedMs = Date.now() - session.startedAt;
+  const completed = session.results.length;
+  const errors = session.results.reduce((a, r) => a + r.errors, 0);
+  const minutes = elapsedMs / 6e4;
+  const wpm = minutes > 0 ? Math.round(completed / minutes * 10) / 10 : 0;
+  return /* @__PURE__ */ jsx7(
+    TypingLayout,
+    {
+      dictId,
+      chapterIndex,
+      totalChapters: loaded.totalChapters,
+      mode,
+      accent: cfg.accent,
+      completed,
+      total: loaded.playlist.length,
+      errors,
+      wpm,
+      elapsedMs,
+      target: currentWord?.name ?? "",
+      typed: inputState.typed,
+      flashError: lastEffect === "wrong",
+      hideTarget: mode === "dictation",
+      phonetic: pickPhonetic(currentWord, cfg.accent),
+      translation: currentWord?.trans ?? []
+    }
+  );
+}
+function pickPhonetic(word, accent) {
+  if (!word) return null;
+  const p = accent === "us" ? word.usphone : word.ukphone;
+  return p ? `/${p}/` : null;
+}
+function fmtTime(ms) {
+  const total = Math.floor(ms / 1e3);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+function TypingLayout(props) {
+  const progressFrac = props.total === 0 ? 0 : props.completed / props.total;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx7(
+      StatusBar,
+      {
+        dictId: props.dictId,
+        chapterIndex: props.chapterIndex,
+        totalChapters: props.totalChapters,
+        mode: props.mode,
+        accent: props.accent,
+        completed: props.completed,
+        total: props.total,
+        elapsedMs: props.elapsedMs
+      }
+    ),
+    /* @__PURE__ */ jsxs3(Box3, { flexGrow: 1, flexDirection: "column", alignItems: "center", justifyContent: "center", children: [
+      /* @__PURE__ */ jsx7(
+        BigWord,
+        {
+          target: props.target,
+          typed: props.typed,
+          error: props.flashError,
+          hideTarget: props.hideTarget
+        }
+      ),
+      props.phonetic && /* @__PURE__ */ jsx7(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { italic: true, color: PALETTE.muted, children: props.phonetic }) }),
+      props.translation.length > 0 && /* @__PURE__ */ jsx7(Box3, { marginTop: 1, flexDirection: "column", alignItems: "center", children: props.translation.slice(0, 2).map((t, i) => /* @__PURE__ */ jsx7(Text3, { color: PALETTE.primary, children: t }, i)) })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(ProgressBar, { frac: progressFrac }),
+      /* @__PURE__ */ jsx7(Box3, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: PALETTE.muted, children: [
+        props.completed,
+        "/",
+        props.total,
+        "  \xB7  ",
+        fmtTime(props.elapsedMs),
+        "  \xB7  ",
+        props.wpm,
+        " wpm  \xB7  ",
+        props.errors,
+        " errors"
+      ] }) }),
+      /* @__PURE__ */ jsx7(Box3, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "Ctrl+N skip  \xB7  Esc pause  \xB7  Tab replay  \xB7  Ctrl+C quit" }) })
+    ] })
+  ] });
+}
+function StatusBar(props) {
+  const left = props.mode === "review" ? `${props.dictId}  \xB7  review  \xB7  ${props.accent}` : `${props.dictId}  \xB7  ch ${props.chapterIndex + 1}/${props.totalChapters}  \xB7  ${props.mode}  \xB7  ${props.accent}`;
+  const right = `${props.completed}/${props.total}  \xB7  ${fmtTime(props.elapsedMs)}`;
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: left }),
+    /* @__PURE__ */ jsx7(Box3, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: right })
+  ] });
+}
+function ProgressBar({ frac }) {
+  const cols = process.stdout.columns ?? 80;
+  const width = Math.max(20, Math.min(72, cols - 16));
+  const filled = Math.round(width * Math.max(0, Math.min(1, frac)));
+  const empty = width - filled;
+  return /* @__PURE__ */ jsxs3(Box3, { justifyContent: "center", children: [
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.accent, children: "\u2501".repeat(filled) }),
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "\u2500".repeat(empty) })
+  ] });
 }
-
-// src/ui/components/Phonetic.tsx
-import { Text as Text2 } from "ink";
-import { jsxs } from "react/jsx-runtime";
-function Phonetic({ word, accent }) {
-  const phon = accent === "us" ? word.usphone : word.ukphone;
-  if (!phon) return null;
-  return /* @__PURE__ */ jsxs(Text2, { dimColor: true, children: [
-    "/",
-    phon,
-    "/"
+function PausedView() {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx7(BigText2, { text: "paused", font: "tiny", colors: [PALETTE.warning] }),
+    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[r] resume   \xB7   [q] quit to menu" }) })
   ] });
 }
-
-// src/ui/components/Translation.tsx
-import { Box as Box2, Text as Text3 } from "ink";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function Translation({ word }) {
-  if (!word.trans || word.trans.length === 0) return null;
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: word.trans.map((t, i) => /* @__PURE__ */ jsx2(Text3, { color: "cyan", children: t }, i)) });
+function ErrorView({ msg }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.error, children: msg }),
+    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[q] back to menu" }) }),
+    /* @__PURE__ */ jsx7(BackKey, {})
+  ] });
 }
-
-// src/ui/components/Progress.tsx
-import { Box as Box3, Text as Text4 } from "ink";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function Progress({ current, total, errors, elapsedMs }) {
-  const minutes = elapsedMs / 6e4;
-  const wpm = minutes > 0 ? Math.round(current / minutes) : 0;
-  const seconds = Math.floor(elapsedMs / 1e3);
-  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs2(Text4, { children: [
-    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "progress " }),
-    /* @__PURE__ */ jsx3(Text4, { bold: true, children: current }),
-    /* @__PURE__ */ jsxs2(Text4, { dimColor: true, children: [
-      "/",
-      total
+function BackKey() {
+  const nav = useNav();
+  useInput3((input, key) => {
+    if (input === "q" || key.escape) nav.back();
+  });
+  return null;
+}
+function Centered({ text, color }) {
+  return /* @__PURE__ */ jsx7(Box3, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx7(Text3, { color, children: text }) });
+}
+function SummaryView(props) {
+  const { summary } = props;
+  const minutes = summary.durationMs / 6e4;
+  const wpm = minutes > 0 ? Math.round(summary.wordCount / minutes * 10) / 10 : 0;
+  const errorWords = Object.keys(summary.perWordErrors).length;
+  const acc = summary.wordCount === 0 ? 1 : Math.max(0, (summary.wordCount - errorWords) / summary.wordCount);
+  const accPct = Math.round(acc * 1e3) / 10;
+  const subtitle = props.mode === "review" ? `${props.dictId}  \xB7  review` : `${props.dictId}  \xB7  chapter ${props.chapterIndex + 1}/${props.totalChapters}  \xB7  ${props.mode}`;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx7(BigText2, { text: "complete", font: "tiny", colors: [PALETTE.success] }),
+    /* @__PURE__ */ jsx7(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: subtitle }) }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 3, flexDirection: "row", justifyContent: "center", children: [
+      /* @__PURE__ */ jsx7(StatCard, { label: "words", value: String(summary.wordCount), color: PALETTE.text }),
+      /* @__PURE__ */ jsx7(
+        StatCard,
+        {
+          label: "errors",
+          value: String(summary.errors),
+          color: summary.errors > 0 ? PALETTE.error : PALETTE.muted
+        }
+      ),
+      /* @__PURE__ */ jsx7(StatCard, { label: "wpm", value: String(wpm), color: PALETTE.accent }),
+      /* @__PURE__ */ jsx7(StatCard, { label: "accuracy", value: `${accPct}%`, color: PALETTE.accent })
     ] }),
-    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  errors " }),
-    /* @__PURE__ */ jsx3(Text4, { color: errors > 0 ? "red" : "green", children: errors }),
-    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  wpm " }),
-    /* @__PURE__ */ jsx3(Text4, { children: wpm }),
-    /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: "  time " }),
-    /* @__PURE__ */ jsxs2(Text4, { children: [
-      Math.floor(seconds / 60),
-      ":",
-      String(seconds % 60).padStart(2, "0")
-    ] })
-  ] }) });
+    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: PALETTE.muted, children: [
+      "elapsed ",
+      fmtTime(summary.durationMs)
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box3, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[n] next chapter  \xB7  [m] review mistakes  \xB7  [q] back to menu" }) })
+  ] });
+}
+function StatCard({ label, value, color }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", marginX: 2, children: [
+    /* @__PURE__ */ jsx7(BigText2, { text: value, font: "tiny", colors: [color] }),
+    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: label })
+  ] });
 }
 
-// src/ui/screens/PracticeScreen.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-function PracticeScreen(props) {
-  const [paused, setPaused] = useState2(false);
-  const [finished, setFinished] = useState2(null);
-  const [audioWarn, setAudioWarn] = useState2(null);
-  const { exit } = useApp2();
-  const audio = useAudio({
-    enabled: props.audio.master,
-    accent: props.accent,
-    autoplayPronunciation: props.audio.autoplayPronunciation,
-    onWarning: setAudioWarn
-  });
-  const lastEffectRef = useRef3(null);
-  const lastIndexRef = useRef3(-1);
-  const { session, lastEffect, tick } = useWordLoop({
-    playlist: props.playlist,
-    enabled: !paused && finished === null,
-    onComplete: (s) => {
-      setFinished(s);
-      Promise.resolve(props.onSessionComplete(sessionSummary(s))).catch((err) => {
-        console.error("Failed to persist session:", err);
+// src/ui/screens/DictBrowser.tsx
+import { useEffect as useEffect6, useState as useState7 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function DictBrowser({ params }) {
+  const nav = useNav();
+  const { cfg, setCfg } = useAppState();
+  const [rows, setRows] = useState7([]);
+  const [loading, setLoading] = useState7(true);
+  const [selected, setSelected] = useState7(0);
+  const [filter, setFilter] = useState7("");
+  const [filterFocus, setFilterFocus] = useState7(false);
+  const [pending, setPending] = useState7(null);
+  const [tick, setTick] = useState7(0);
+  const refresh = async () => {
+    const reg = await loadRegistry();
+    const flagged = await Promise.all(
+      reg.map(async (e) => ({ entry: e, local: await isLocallyAvailable(e.id) }))
+    );
+    setRows(flagged);
+    setLoading(false);
+  };
+  useEffect6(() => {
+    void refresh();
+  }, [tick]);
+  const filtered = filter ? rows.filter((r) => filterRegistry([r.entry], filter).length > 0) : rows;
+  const safeSelected = Math.max(0, Math.min(filtered.length - 1, selected));
+  const current = filtered[safeSelected];
+  useInput4((input, key) => {
+    if (filterFocus) {
+      if (key.escape || key.return) {
+        setFilterFocus(false);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setFilter((f) => f.slice(0, -1));
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setFilter((f) => f + input);
+      }
+      return;
+    }
+    if (key.upArrow) setSelected((i) => Math.max(0, i - 1));
+    if (key.downArrow) setSelected((i) => Math.min(filtered.length - 1, i + 1));
+    if (input === "/") {
+      setFilterFocus(true);
+      return;
+    }
+    if (key.escape || input === "b") {
+      nav.back();
+      return;
+    }
+    if (!current) return;
+    if (key.return) {
+      void (async () => {
+        await setCfg({ ...cfg, defaultDict: current.entry.id });
+        if (params?.pickerMode === "choose-then-practice") {
+          nav.replace({
+            name: "practice",
+            params: { dictId: current.entry.id, chapterIndex: 0, mode: cfg.defaultMode }
+          });
+        } else {
+          nav.back();
+        }
+      })();
+      return;
+    }
+    if (input === "p") {
+      nav.replace({
+        name: "practice",
+        params: { dictId: current.entry.id, chapterIndex: 0, mode: cfg.defaultMode }
       });
-    },
-    onEscape: () => setPaused((p) => !p),
-    onTab: () => {
-      const cur = session.current ? props.playlist[session.current.wordIndex] : void 0;
-      if (cur) void audio.pronounce(cur.name);
+      return;
+    }
+    if (input === "r" && current.local) {
+      setPending({ kind: "removing", id: current.entry.id });
+      void (async () => {
+        try {
+          await removeDictionary(current.entry.id);
+          setPending(null);
+          setTick((t) => t + 1);
+        } catch (err) {
+          setPending({ kind: "error", id: current.entry.id, msg: err.message });
+        }
+      })();
+      return;
+    }
+    if (input === "u") {
+      setPending({ kind: "pulling", id: current.entry.id });
+      void (async () => {
+        try {
+          await pullDictionary(current.entry.id);
+          setPending(null);
+          setTick((t) => t + 1);
+        } catch (err) {
+          setPending({ kind: "error", id: current.entry.id, msg: err.message });
+        }
+      })();
     }
   });
-  useEffect3(() => {
-    if (lastEffect === null) return;
-    if (lastEffect === lastEffectRef.current) return;
-    lastEffectRef.current = lastEffect;
-    if (lastEffect === "wrong" && props.audio.feedback) audio.wrong();
-    if (lastEffect === "progress" && props.audio.keystroke) audio.keystroke();
-    if (lastEffect === "correct") {
-      if (props.audio.feedback) audio.correct();
-      if (props.audio.keystroke) audio.keystroke();
+  if (loading) {
+    return /* @__PURE__ */ jsx8(Box4, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: "loading dictionaries\u2026" }) });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Text4, { bold: true, color: PALETTE.accent, children: "Dictionaries" }),
+      /* @__PURE__ */ jsx8(Box4, { flexGrow: 1 }),
+      /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: filterFocus ? `/ ${filter}_` : filter ? `/ ${filter}` : `${filtered.length} entries` })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", width: "60%", children: filtered.slice(Math.max(0, safeSelected - 8), safeSelected + 16).map((row, vi) => {
+        const i = Math.max(0, safeSelected - 8) + vi;
+        const active = i === safeSelected;
+        const isDefault = cfg.defaultDict === row.entry.id;
+        return /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx8(Text4, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+          /* @__PURE__ */ jsx8(Text4, { color: row.local ? PALETTE.accent : PALETTE.muted, children: row.local ? "\u25CF" : "\u25CB" }),
+          /* @__PURE__ */ jsx8(Text4, { children: " " }),
+          /* @__PURE__ */ jsx8(Text4, { color: isDefault ? PALETTE.success : PALETTE.muted, children: isDefault ? "\u2605" : " " }),
+          /* @__PURE__ */ jsx8(Text4, { children: " " }),
+          /* @__PURE__ */ jsx8(Text4, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: row.entry.id.slice(0, 14).padEnd(15) }),
+          /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: String(row.entry.length).padStart(5) })
+        ] }, row.entry.id);
+      }) }),
+      /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", width: "40%", paddingLeft: 2, children: current && /* @__PURE__ */ jsxs4(Fragment2, { children: [
+        /* @__PURE__ */ jsx8(Text4, { bold: true, color: PALETTE.text, children: current.entry.name }),
+        /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: current.entry.id }),
+        /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
+          current.entry.language,
+          " \xB7 ",
+          current.entry.category,
+          " \xB7 ",
+          current.entry.length,
+          " words"
+        ] }) }),
+        /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.primary, children: current.entry.description || "(no description)" }) }),
+        current.entry.tags.length > 0 && /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
+          "tags: ",
+          current.entry.tags.join(", ")
+        ] }) }),
+        /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+          /* @__PURE__ */ jsx8(Text4, { color: current.local ? PALETTE.accent : PALETTE.muted, children: current.local ? "local \u2713" : "not local" }),
+          cfg.defaultDict === current.entry.id && /* @__PURE__ */ jsx8(Text4, { color: PALETTE.success, children: "  \xB7 default \u2605" })
+        ] })
+      ] }) })
+    ] }),
+    pending && /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+      pending.kind === "pulling" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.warning, children: [
+        "pulling ",
+        pending.id,
+        "\u2026"
+      ] }),
+      pending.kind === "removing" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.warning, children: [
+        "removing ",
+        pending.id,
+        "\u2026"
+      ] }),
+      pending.kind === "error" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.error, children: [
+        "error on ",
+        pending.id,
+        ": ",
+        pending.msg
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: "\u2191/\u2193 select  \xB7  Enter set default  \xB7  p practice  \xB7  u pull  \xB7  r remove  \xB7  / filter  \xB7  Esc back" }) })
+  ] });
+}
+
+// src/ui/screens/ConfigEditor.tsx
+import { useState as useState8 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput5 } from "ink";
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var FIELDS = [
+  { kind: "dictRef", path: "defaultDict", label: "default dict" },
+  { kind: "enum", path: "defaultMode", label: "default mode", options: ["order", "dictation", "review", "random", "loop"] },
+  { kind: "enum", path: "accent", label: "accent", options: ["us", "uk"] },
+  { kind: "enum", path: "mirror", label: "mirror", options: ["jsdelivr", "github"] },
+  { kind: "int", path: "chapterSize", label: "chapter size", min: 1, max: 200 },
+  { kind: "bool", path: "autoplayPronunciation", label: "autoplay pronunciation" },
+  { kind: "bool", path: "sounds.master", label: "sounds master" },
+  { kind: "bool", path: "sounds.keystroke", label: "sounds keystroke" },
+  { kind: "bool", path: "sounds.feedback", label: "sounds feedback" },
+  { kind: "string", path: "sounds.keySoundName", label: "sounds key sound" }
+];
+function getByPath2(cfg, path) {
+  return path.split(".").reduce((acc, k) => {
+    if (acc && typeof acc === "object") return acc[k];
+    return void 0;
+  }, cfg);
+}
+function ConfigEditor() {
+  const nav = useNav();
+  const { cfg, setCfg } = useAppState();
+  const [selected, setSelected] = useState8(0);
+  const [editing, setEditing] = useState8(false);
+  const [draft, setDraft] = useState8("");
+  const [error, setError] = useState8(null);
+  const field = FIELDS[selected];
+  const currentValue = getByPath2(cfg, field.path);
+  const commit = async (raw) => {
+    try {
+      const next = setByPath(cfg, field.path, raw);
+      await setCfg(next);
+      setEditing(false);
+      setError(null);
+    } catch (err) {
+      setError(err.message);
     }
-  }, [lastEffect, audio, props.audio.feedback, props.audio.keystroke]);
-  useEffect3(() => {
-    const idx = session.current?.wordIndex ?? -1;
-    if (idx === -1) return;
-    if (idx === lastIndexRef.current) return;
-    lastIndexRef.current = idx;
-    const cur = props.playlist[idx];
-    const next = props.playlist[idx + 1];
-    if (cur && props.audio.autoplayPronunciation) audio.pronounce(cur.name);
-    if (next) audio.prefetch(next.name);
-  }, [session.current?.wordIndex, audio, props.audio.autoplayPronunciation, props.playlist]);
-  void tick;
-  useInput2(
-    (input) => {
-      if (input === "q") exit();
-      if (input === "r") setPaused(false);
-    },
-    { isActive: paused && finished === null }
-  );
-  useInput2(
-    (input) => {
-      if (input === "q") {
-        props.onQuit?.();
-        exit();
+  };
+  useInput5((input, key) => {
+    if (editing && field.kind === "string") {
+      if (key.escape) {
+        setEditing(false);
+        setError(null);
+        return;
       }
-      if (input === "n") {
-        props.onAdvanceChapter?.();
-        exit();
+      if (key.return) {
+        void commit(draft);
+        return;
       }
-      if (input === "m") {
-        props.onReviewMistakes?.();
-        exit();
+      if (key.backspace || key.delete) {
+        setDraft((d) => d.slice(0, -1));
+        return;
       }
-    },
-    { isActive: finished !== null }
+      if (input && !key.ctrl && !key.meta) setDraft((d) => d + input);
+      return;
+    }
+    if (editing && field.kind === "int") {
+      if (key.escape) {
+        setEditing(false);
+        setError(null);
+        return;
+      }
+      if (key.return) {
+        void commit(draft);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setDraft((d) => d.slice(0, -1));
+        return;
+      }
+      if (/^[0-9]$/.test(input)) setDraft((d) => d + input);
+      return;
+    }
+    if (key.escape || input === "b") {
+      nav.back();
+      return;
+    }
+    if (key.upArrow) {
+      setSelected((i) => (i - 1 + FIELDS.length) % FIELDS.length);
+      setError(null);
+      return;
+    }
+    if (key.downArrow) {
+      setSelected((i) => (i + 1) % FIELDS.length);
+      setError(null);
+      return;
+    }
+    if (field.kind === "bool" && (input === " " || key.return)) {
+      void commit(currentValue ? "false" : "true");
+      return;
+    }
+    if (field.kind === "enum" && (key.leftArrow || key.rightArrow)) {
+      const idx = field.options.indexOf(String(currentValue));
+      const delta = key.rightArrow ? 1 : -1;
+      const next = field.options[(idx + delta + field.options.length) % field.options.length];
+      void commit(next);
+      return;
+    }
+    if (field.kind === "dictRef" && key.return) {
+      nav.navigate({ name: "dict", params: { pickerMode: "set-default" } });
+      return;
+    }
+    if ((field.kind === "string" || field.kind === "int") && key.return) {
+      setDraft(String(currentValue ?? ""));
+      setEditing(true);
+      setError(null);
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx9(Text5, { bold: true, color: PALETTE.accent, children: "Config" }),
+    /* @__PURE__ */ jsx9(Box5, { marginTop: 1, flexDirection: "column", flexGrow: 1, children: FIELDS.map((f, i) => {
+      const active = i === selected;
+      const value = getByPath2(cfg, f.path);
+      const display = renderValue(f, value, active && editing ? draft : null);
+      return /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx9(Text5, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+        /* @__PURE__ */ jsx9(Text5, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: f.label.padEnd(28) }),
+        /* @__PURE__ */ jsx9(Text5, { color: active ? PALETTE.accent : PALETTE.muted, children: display })
+      ] }, f.path);
+    }) }),
+    error && /* @__PURE__ */ jsx9(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { color: PALETTE.error, children: [
+      "! ",
+      error
+    ] }) }),
+    /* @__PURE__ */ jsx9(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text5, { color: PALETTE.muted, children: hintFor(field, editing) }) })
+  ] });
+}
+function renderValue(field, value, draft) {
+  if (draft !== null) return `${draft}_`;
+  if (field.kind === "bool") return value ? "\u2713 on" : "\u2717 off";
+  if (field.kind === "dictRef") return String(value ?? "(none)");
+  if (field.kind === "enum") return `< ${value} >`;
+  return String(value ?? "");
+}
+function hintFor(field, editing) {
+  if (editing) return "type to edit  \xB7  Enter save  \xB7  Esc cancel";
+  if (field.kind === "bool") return "space toggle  \xB7  \u2191/\u2193 move  \xB7  Esc back";
+  if (field.kind === "enum") return "\u2190/\u2192 cycle  \xB7  \u2191/\u2193 move  \xB7  Esc back";
+  if (field.kind === "dictRef") return "Enter pick dict  \xB7  \u2191/\u2193 move  \xB7  Esc back";
+  return "Enter edit  \xB7  \u2191/\u2193 move  \xB7  Esc back";
+}
+
+// src/ui/screens/StatsViewer.tsx
+import { useEffect as useEffect7, useState as useState9 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput6 } from "ink";
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var DAY_WINDOWS = [7, 14, 30, 90];
+function StatsViewer() {
+  const nav = useNav();
+  const [sessions, setSessions] = useState9(null);
+  const [book, setBook] = useState9(null);
+  const [windowIdx, setWindowIdx] = useState9(1);
+  useEffect7(() => {
+    void (async () => {
+      const [s, b] = await Promise.all([loadSessions(), loadMistakes()]);
+      setSessions(s);
+      setBook(b);
+    })();
+  }, []);
+  useInput6((input, key) => {
+    if (key.escape || input === "b" || input === "q") {
+      nav.back();
+      return;
+    }
+    if (input === "n") setWindowIdx((i) => (i + 1) % DAY_WINDOWS.length);
+    if (input === "N") setWindowIdx((i) => (i - 1 + DAY_WINDOWS.length) % DAY_WINDOWS.length);
+  });
+  if (!sessions || !book) {
+    return /* @__PURE__ */ jsx10(Box6, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "loading stats\u2026" }) });
+  }
+  if (sessions.length === 0) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "No practice history yet." }),
+      /* @__PURE__ */ jsx10(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "Run a practice session first." }) }),
+      /* @__PURE__ */ jsx10(Box6, { marginTop: 2, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "[q] back" }) })
+    ] });
+  }
+  const days = DAY_WINDOWS[windowIdx];
+  const buckets = dailyBuckets(sessions, days);
+  const streak = dailyStreak(sessions);
+  const totalWords = sessions.reduce((a, s) => a + s.wordCount, 0);
+  const totalErrors = sessions.reduce((a, s) => a + s.errors, 0);
+  const totalMs = sessions.reduce((a, s) => a + s.durationMs, 0);
+  const firstTryWords = sessions.reduce(
+    (a, s) => a + (s.wordCount - Object.keys(s.perWordErrors).length),
+    0
   );
-  if (finished) {
-    const summary = sessionSummary(finished);
-    const minutes = summary.durationMs / 6e4;
-    const wpm = minutes > 0 ? Math.round(summary.wordCount / minutes * 10) / 10 : 0;
-    const errorWords = Object.keys(summary.perWordErrors).length;
-    const acc = summary.wordCount === 0 ? 1 : Math.max(0, (summary.wordCount - errorWords) / summary.wordCount);
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: "green", children: [
-      /* @__PURE__ */ jsxs3(Text5, { bold: true, color: "green", children: [
-        "Chapter complete: ",
-        props.dictId,
-        " chapter ",
-        props.chapterNumber,
-        "/",
-        props.totalChapters
+  const overallWpm = totalMs > 0 ? Math.round(totalWords / (totalMs / 6e4) * 10) / 10 : 0;
+  const overallAcc = totalWords === 0 ? 1 : firstTryWords / totalWords;
+  const recent = sessions.slice(-5).reverse();
+  const top = topN(book, 8);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx10(Text6, { bold: true, color: PALETTE.accent, children: "Stats" }),
+    /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "lifetime" }),
+      /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Stat, { label: "sessions", value: String(sessions.length) }),
+        /* @__PURE__ */ jsx10(Stat, { label: "words", value: String(totalWords) }),
+        /* @__PURE__ */ jsx10(Stat, { label: "errors", value: String(totalErrors) }),
+        /* @__PURE__ */ jsx10(Stat, { label: "wpm", value: String(overallWpm), accent: true }),
+        /* @__PURE__ */ jsx10(Stat, { label: "accuracy", value: `${Math.round(overallAcc * 1e3) / 10}%`, accent: true }),
+        /* @__PURE__ */ jsx10(Stat, { label: "streak", value: `${streak}d`, accent: true })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+        "last ",
+        days,
+        " days  (n / N to cycle window)"
       ] }),
-      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text5, { children: [
-        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "words " }),
-        /* @__PURE__ */ jsx4(Text5, { bold: true, children: summary.wordCount }),
-        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  errors " }),
-        /* @__PURE__ */ jsx4(Text5, { color: summary.errors > 0 ? "red" : "green", children: summary.errors }),
-        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  wpm " }),
-        /* @__PURE__ */ jsx4(Text5, { children: wpm }),
-        /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "  accuracy " }),
-        /* @__PURE__ */ jsxs3(Text5, { children: [
-          Math.round(acc * 1e3) / 10,
+      /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs6(Box6, { children: [
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "wpm     ".padEnd(10) }),
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.wpm)) }),
+          /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+            "  max ",
+            Math.round(Math.max(...buckets.map((b) => b.wpm)))
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs6(Box6, { children: [
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "accuracy".padEnd(10) }),
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.accuracy * 100)) })
+        ] }),
+        /* @__PURE__ */ jsxs6(Box6, { children: [
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "sessions".padEnd(10) }),
+          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.sessions)) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "recent sessions" }),
+      recent.map((s, i) => /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+          "  ",
+          s.ts.replace("T", " ").slice(0, 16),
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.text, children: s.dictId.padEnd(14) }),
+        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+          " ",
+          "ch",
+          String(s.chapter + 1).padStart(3),
+          "  ",
+          s.mode.padEnd(9),
+          " ",
+          String(s.wordCount).padStart(3),
+          "w  ",
+          s.errors,
+          "err  ",
+          computeWPM(s),
+          "wpm  ",
+          Math.round(accuracy(s) * 1e3) / 10,
           "%"
         ] })
-      ] }) }),
-      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[n] next chapter  [m] review mistakes  [q] quit" }) })
-    ] });
+      ] }, i))
+    ] }),
+    top.length > 0 && /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "top mistakes" }),
+      top.map(([word, entry]) => /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.error, children: [
+          "  ",
+          String(entry.count).padStart(3),
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.text, children: word.padEnd(20) }),
+        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: entry.dictIds.join(", ") })
+      ] }, word))
+    ] }),
+    /* @__PURE__ */ jsx10(Box6, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx10(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "n / N cycle window  \xB7  q back" }) })
+  ] });
+}
+function Stat({ label, value, accent = false }) {
+  return /* @__PURE__ */ jsxs6(Box6, { marginRight: 3, children: [
+    /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+      label,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx10(Text6, { bold: true, color: accent ? PALETTE.accent : PALETTE.text, children: value })
+  ] });
+}
+
+// src/ui/screens/WordLookup.tsx
+import { useEffect as useEffect8, useState as useState10 } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput7 } from "ink";
+import { readdir } from "fs/promises";
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+async function listLocalDictIds() {
+  try {
+    const files = await readdir(paths.dictsDir);
+    return files.filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).map((f) => f.replace(/\.json$/, ""));
+  } catch {
+    return [];
+  }
+}
+function WordLookup() {
+  const nav = useNav();
+  const [query, setQuery] = useState10("");
+  const [allWords, setAllWords] = useState10([]);
+  const [book, setBook] = useState10({});
+  const [loading, setLoading] = useState10(true);
+  const [selected, setSelected] = useState10(0);
+  useEffect8(() => {
+    void (async () => {
+      const ids = await listLocalDictIds();
+      const collected = [];
+      for (const id of ids) {
+        const words = await loadLocalDictionary(id);
+        if (!words) continue;
+        for (const w of words) collected.push({ dictId: id, word: w });
+      }
+      setAllWords(collected);
+      setBook(await loadMistakes());
+      setLoading(false);
+    })();
+  }, []);
+  const q = query.toLowerCase().trim();
+  const filtered = q ? allWords.filter((h) => h.word.name.toLowerCase().includes(q)).slice(0, 50) : [];
+  useInput7((input, key) => {
+    if (key.escape) {
+      nav.back();
+      return;
+    }
+    if (key.upArrow) {
+      setSelected((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelected((i) => Math.min(filtered.length - 1, i + 1));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((s) => s.slice(0, -1));
+      setSelected(0);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && input.trim().length > 0) {
+      setQuery((s) => s + input);
+      setSelected(0);
+    }
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsx11(Box7, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "indexing local dictionaries\u2026" }) });
   }
-  if (paused) {
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, borderStyle: "round", borderColor: "yellow", children: [
-      /* @__PURE__ */ jsx4(Text5, { bold: true, color: "yellow", children: "Paused" }),
-      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[r] resume  [q] quit" }) })
+  if (allWords.length === 0) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "No local dictionaries." }),
+      /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "Pull one in Dictionaries first." }) }),
+      /* @__PURE__ */ jsx11(Box7, { marginTop: 2, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "[Esc] back" }) })
     ] });
   }
-  const currentWord = session.current ? props.playlist[session.current.wordIndex] : props.playlist[props.playlist.length - 1];
-  const inputState = session.current?.input ?? initialState("");
-  const elapsedMs = Date.now() - session.startedAt;
-  const completed = session.results.length;
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, paddingY: 0, children: [
-    /* @__PURE__ */ jsxs3(Box4, { children: [
-      /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: props.dictId }),
-      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
-        " \xB7 chapter ",
-        props.chapterNumber,
-        "/",
-        props.totalChapters
-      ] }),
-      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
-        " \xB7 mode ",
-        props.mode
-      ] }),
-      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
-        " \xB7 accent ",
-        props.accent
+  const current = filtered[selected];
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx11(Text7, { bold: true, color: PALETTE.accent, children: "Word lookup" }),
+      /* @__PURE__ */ jsx11(Box7, { flexGrow: 1 }),
+      /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+        allWords.length,
+        " words across local dicts"
       ] })
     ] }),
-    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(WordInput, { state: inputState, hideTarget: props.mode === "dictation", flashError: lastEffect === "wrong" }) }),
-    currentWord && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Phonetic, { word: currentWord, accent: props.accent }) }),
-    currentWord && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Translation, { word: currentWord }) }),
-    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Progress, { current: completed, total: props.playlist.length, errors: inputState.errorsThisWord, elapsedMs }) }),
-    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "[Esc] pause   [Tab] replay pronunciation   [Ctrl+C] quit" }) }),
-    audioWarn && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text5, { color: "yellow", children: audioWarn }) })
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "> " }),
+      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.text, children: query }),
+      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.accent, children: "_" })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", width: "40%", children: [
+        filtered.map((h, i) => {
+          const active = i === selected;
+          return /* @__PURE__ */ jsxs7(Box7, { children: [
+            /* @__PURE__ */ jsx11(Text7, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+            /* @__PURE__ */ jsx11(Text7, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: h.word.name.padEnd(20) }),
+            /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: h.dictId })
+          ] }, `${h.dictId}-${h.word.name}-${i}`);
+        }),
+        filtered.length === 0 && q && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+          'no matches for "',
+          query,
+          '"'
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx11(Box7, { flexDirection: "column", width: "60%", paddingLeft: 2, children: current && /* @__PURE__ */ jsxs7(Fragment3, { children: [
+        /* @__PURE__ */ jsx11(Text7, { bold: true, color: PALETTE.text, children: current.word.name }),
+        /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+          current.word.usphone && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+            "US /",
+            current.word.usphone,
+            "/   "
+          ] }),
+          current.word.ukphone && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+            "UK /",
+            current.word.ukphone,
+            "/"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx11(Box7, { marginTop: 1, flexDirection: "column", children: (current.word.trans ?? []).map((t, i) => /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.primary, children: [
+          "\xB7 ",
+          t
+        ] }, i)) }),
+        /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+          "in: ",
+          current.dictId
+        ] }) }),
+        book[current.word.name] && /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+          /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.error, children: [
+            "mistakes: ",
+            book[current.word.name].count
+          ] }),
+          /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
+            " ",
+            "(last ",
+            book[current.word.name].lastSeen.slice(0, 10),
+            ")"
+          ] })
+        ] })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "type to filter  \xB7  \u2191/\u2193 select  \xB7  Esc back" }) })
   ] });
 }
 
+// src/ui/App.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function App({ initial, initialCfg }) {
+  return /* @__PURE__ */ jsx12(AppStateProvider, { initialCfg, children: /* @__PURE__ */ jsx12(AudioStatusProvider, { disabled: !initialCfg.sounds.master, children: /* @__PURE__ */ jsx12(NavProvider, { initial, children: /* @__PURE__ */ jsx12(Fullscreen, { children: /* @__PURE__ */ jsx12(Router, {}) }) }) }) });
+}
+function Router() {
+  const nav = useNav();
+  const { cfg } = useAppState();
+  const { exit } = useApp4();
+  useInput8((input, key) => {
+    if (key.ctrl && input === "c") exit();
+  });
+  const frame = nav.current;
+  switch (frame.name) {
+    case "main":
+      return /* @__PURE__ */ jsx12(MainMenu, { cfg });
+    case "practice":
+      return /* @__PURE__ */ jsx12(PracticeScreen, { params: frame.params });
+    case "dict":
+      return /* @__PURE__ */ jsx12(DictBrowser, { params: frame.params });
+    case "config":
+      return /* @__PURE__ */ jsx12(ConfigEditor, {});
+    case "stats":
+      return /* @__PURE__ */ jsx12(StatsViewer, {});
+    case "word":
+      return /* @__PURE__ */ jsx12(WordLookup, {});
+  }
+}
+
 // src/commands/practice.ts
 var MODES = ["order", "dictation", "review", "random", "loop"];
 function isMode(v) {
   return MODES.includes(v);
 }
-async function runChapter(opts) {
-  let outcome = "done";
-  const onSessionComplete = async (summary) => {
-    const rec = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      dictId: opts.dictId,
-      chapter: opts.chapterIndex,
-      mode: opts.mode,
-      wordCount: summary.wordCount,
-      errors: summary.errors,
-      durationMs: summary.durationMs,
-      perWordErrors: summary.perWordErrors
-    };
-    await appendSession(rec);
-    if (Object.keys(summary.perWordErrors).length > 0) {
-      let book = await loadMistakes();
-      for (const [word, n] of Object.entries(summary.perWordErrors)) {
-        book = bump(book, word, opts.dictId, n);
-      }
-      await saveMistakes(book);
-    }
-  };
-  const { waitUntilExit } = render(
-    createElement(PracticeScreen, {
-      dictId: opts.dictId,
-      chapterNumber: opts.chapterIndex + 1,
-      totalChapters: opts.totalChapters,
-      playlist: opts.playlist,
-      mode: opts.mode,
-      accent: opts.accent,
-      audio: opts.audio,
-      onSessionComplete,
-      onAdvanceChapter: () => {
-        outcome = "next";
-      },
-      onReviewMistakes: () => {
-        outcome = "review";
-      },
-      onQuit: () => {
-        outcome = "quit";
-      }
-    })
-  );
-  await waitUntilExit();
-  return outcome;
-}
 async function runPractice(dictIdArg, options) {
   if (!process.stdout.isTTY) {
     console.error(chalk3.red("Practice requires an interactive TTY."));
@@ -1239,78 +2296,15 @@ async function runPractice(dictIdArg, options) {
     process.exitCode = 1;
     return;
   }
-  const words = await ensureDictionary(dictId);
-  const chapters = chunkChapters(words, cfg.chapterSize);
-  if (chapters.length === 0) {
-    console.error(chalk3.red(`Dictionary ${dictId} is empty.`));
-    process.exitCode = 1;
-    return;
-  }
-  let idx = Math.max(0, Math.min(chapters.length - 1, Number(options.chapter ?? 1) - 1));
-  const total = chapters.length;
-  const accent = cfg.accent;
-  const audioCfg = {
-    master: cfg.sounds.master,
-    keystroke: cfg.sounds.keystroke,
-    feedback: cfg.sounds.feedback,
-    autoplayPronunciation: cfg.autoplayPronunciation
-  };
-  if (mode === "review") {
-    const book = await loadMistakes();
-    const reviewWords = words.filter((w) => book[w.name]?.count);
-    if (reviewWords.length === 0) {
-      console.log(chalk3.yellow("Mistake book is empty for this dictionary. Practice some chapters first."));
-      return;
-    }
-    await runChapter({
-      dictId,
-      chapterIndex: 0,
-      totalChapters: 1,
-      playlist: reviewWords.slice(0, cfg.chapterSize),
-      mode,
-      accent,
-      audio: audioCfg
-    });
-    return;
-  }
-  while (idx < chapters.length) {
-    const chapter = chapters[idx];
-    const playlist = buildPlaylist(chapter, mode);
-    const result = await runChapter({
-      dictId,
-      chapterIndex: idx,
-      totalChapters: total,
-      playlist,
-      mode,
-      accent,
-      audio: audioCfg
-    });
-    if (result === "next") {
-      if (mode === "loop") continue;
-      idx++;
-    } else if (result === "review") {
-      const book = await loadMistakes();
-      const reviewWords = words.filter((w) => book[w.name]?.count).slice(0, cfg.chapterSize);
-      if (reviewWords.length === 0) {
-        console.log(chalk3.yellow("No mistakes to review."));
-        return;
-      }
-      await runChapter({
-        dictId,
-        chapterIndex: 0,
-        totalChapters: 1,
-        playlist: reviewWords,
-        mode: "order",
-        accent,
-        audio: audioCfg
-      });
-      return;
-    } else {
-      return;
-    }
-  }
-  console.log(chalk3.green(`Reached end of ${dictId} (${total} chapters). Nice work.`));
-  void chapterCount;
+  const chapterIndex = Math.max(0, Number(options.chapter ?? 1) - 1);
+  const { waitUntilExit } = render(
+    createElement(App, {
+      initial: { name: "practice", params: { dictId, chapterIndex, mode } },
+      initialCfg: cfg
+    }),
+    { patchConsole: false, exitOnCtrlC: false }
+  );
+  await waitUntilExit();
 }
 function buildPracticeCommand() {
   return new Command3("practice").argument("[dictId]", "dictionary id; falls back to config.defaultDict").description("Start a typing practice session").option("-c, --chapter <n>", "chapter number (1-based)", "1").option("-m, --mode <mode>", "order | dictation | review | random | loop").action(async (dictIdArg, options) => {
@@ -1377,10 +2371,10 @@ Top ${top.length} mistakes`));
 // src/commands/word.ts
 import { Command as Command5 } from "commander";
 import chalk5 from "chalk";
-import { readdir } from "fs/promises";
-async function listLocalDictIds() {
+import { readdir as readdir2 } from "fs/promises";
+async function listLocalDictIds2() {
   try {
-    const files = await readdir(paths.dictsDir);
+    const files = await readdir2(paths.dictsDir);
     return files.filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).map((f) => f.replace(/\.json$/, ""));
   } catch {
     return [];
@@ -1389,7 +2383,7 @@ async function listLocalDictIds() {
 function buildWordCommand() {
   return new Command5("word").argument("<keyword>").description("Look up a word across local dictionaries").option("--exact", "require exact (case-insensitive) match").action(async (keyword, opts) => {
     const q = keyword.toLowerCase();
-    const ids = await listLocalDictIds();
+    const ids = await listLocalDictIds2();
     if (ids.length === 0) {
       console.log(chalk5.yellow("No local dictionaries. Run `qwerty dict pull <id>` first."));
       return;
@@ -1442,107 +2436,22 @@ function buildWordCommand() {
 // src/commands/menu.ts
 import { render as render2 } from "ink";
 import { createElement as createElement2 } from "react";
-import chalk6 from "chalk";
-
-// src/ui/screens/MainMenu.tsx
-import { useState as useState3 } from "react";
-import { Box as Box5, Text as Text6, useApp as useApp3, useInput as useInput3 } from "ink";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-var ITEMS = [
-  { key: "p", label: "Practice", hint: "qwerty practice <dictId>" },
-  { key: "d", label: "Dictionaries", hint: "qwerty dict list / search / pull" },
-  { key: "w", label: "Word lookup", hint: "qwerty word <keyword>" },
-  { key: "s", label: "Stats", hint: "qwerty stats" },
-  { key: "c", label: "Config", hint: "qwerty config list" },
-  { key: "q", label: "Quit", hint: "Ctrl+C also exits" }
-];
-function MainMenu({
-  defaultDict,
-  onAction
-}) {
-  const [selected, setSelected] = useState3(0);
-  const { exit } = useApp3();
-  useInput3((input, key) => {
-    if (key.upArrow) setSelected((i) => (i - 1 + ITEMS.length) % ITEMS.length);
-    if (key.downArrow) setSelected((i) => (i + 1) % ITEMS.length);
-    if (key.return) {
-      const item = ITEMS[selected];
-      if (item.key === "q") {
-        exit();
-        return;
-      }
-      if (item.key === "p") onAction("practice");
-    }
-    for (const it of ITEMS) {
-      if (input === it.key) {
-        if (it.key === "q") {
-          exit();
-          return;
-        }
-        if (it.key === "p") onAction("practice");
-      }
-    }
-  });
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
-    /* @__PURE__ */ jsx5(Text6, { bold: true, color: "cyan", children: "qwerty-cli" }),
-    /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: "typing practice for English vocabulary, in your terminal" }),
-    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, flexDirection: "column", children: ITEMS.map((it, i) => /* @__PURE__ */ jsxs4(Text6, { children: [
-      i === selected ? chalkArrow() : "  ",
-      /* @__PURE__ */ jsxs4(Text6, { bold: i === selected, color: i === selected ? "cyan" : void 0, children: [
-        "[",
-        it.key,
-        "]"
-      ] }),
-      " ",
-      /* @__PURE__ */ jsx5(Text6, { bold: i === selected, children: it.label.padEnd(14) }),
-      /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: it.hint })
-    ] }, it.key)) }),
-    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
-      "default dict: ",
-      defaultDict ?? "none \u2014 set with `qwerty config set defaultDict <id>`"
-    ] }) }),
-    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: "\u2191/\u2193 navigate \xB7 Enter to select \xB7 letters jump" }) })
-  ] });
-}
-function chalkArrow() {
-  return "> ";
-}
-
-// src/commands/menu.ts
 async function runMainMenu() {
   if (!process.stdout.isTTY) {
     console.log("qwerty-cli \u2014 run `qwerty --help` for available commands.");
     return;
   }
   const cfg = await loadConfig();
-  let chosen = null;
-  const { waitUntilExit, unmount } = render2(
-    createElement2(MainMenu, {
-      defaultDict: cfg.defaultDict,
-      onAction: (action) => {
-        chosen = action;
-        unmount();
-      }
-    })
+  const { waitUntilExit } = render2(
+    createElement2(App, { initial: { name: "main" }, initialCfg: cfg }),
+    { patchConsole: false, exitOnCtrlC: false }
   );
   await waitUntilExit();
-  if (chosen === "practice") {
-    if (cfg.defaultDict) {
-      console.log(chalk6.dim(`Tip: \`qwerty practice ${cfg.defaultDict}\` skips this menu next time.`));
-      await runPractice(cfg.defaultDict, {});
-    } else {
-      console.log(
-        chalk6.yellow(
-          "No default dictionary set. Run `qwerty dict pull <id>` then `qwerty config set defaultDict <id>`."
-        )
-      );
-    }
-  }
 }
 
 // src/cli.ts
 var program = new Command6();
-program.name("qwerty").description("Terminal clone of qwerty-learner \u2014 typing practice for English vocabulary").version("0.1.0");
+program.name("qwerty").description("Terminal clone of qwerty-learner \u2014 typing practice for English vocabulary").version(package_default.version);
 program.addCommand(buildPracticeCommand());
 program.addCommand(buildDictCommand());
 program.addCommand(buildWordCommand());