saterminal 0.3.0 → 0.3.2

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "saterminal",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "bin": {
-    "sat": "./src/main.ts"
+    "sat": "src/main.ts"
   },
+  "files": [
+    "src"
+  ],
   "scripts": {
     "dev": "bun run src/main.ts",
     "start": "bun run src/main.ts",

package/src/api.ts

@@ -1,11 +1,12 @@
 import { defaultFocus, domainsForSkills } from "./focus.ts";
 import type { Focus, PracticeQuestion, QuestionDetail, QuestionMeta } from "./types.ts";
 
-const baseUrl = "https://practicesat.vercel.app/api";
+const baseUrl = "https://mysatprep.fun/api";
 
 type ApiEnvelope<T> = {
   success: boolean;
   data: T;
+  error?: string;
   message?: string;
 };
 
@@ -18,7 +19,7 @@ export async function fetchQuestionBank(excludeIds: Iterable<string> = [], focus
 
   const response = await fetchJson<ApiEnvelope<QuestionMeta[]>>(`${baseUrl}/get-questions?${params}`);
   if (!response.success || !Array.isArray(response.data)) {
-    throw new Error(response.message || "Question bank fetch failed.");
+    throw new Error(response.error || response.message || "Question bank fetch failed.");
   }
 
   return response.data.filter((item) => item.questionId && item.external_id);
@@ -27,7 +28,7 @@ export async function fetchQuestionBank(excludeIds: Iterable<string> = [], focus
 export async function fetchQuestion(id: string): Promise<QuestionDetail> {
   const response = await fetchJson<ApiEnvelope<QuestionDetail>>(`${baseUrl}/question/${id}`);
   if (!response.success || !response.data) {
-    throw new Error(response.message || `Question ${id} fetch failed.`);
+    throw new Error(response.error || response.message || `Question ${id} fetch failed.`);
   }
 
   return response.data;
@@ -69,10 +70,44 @@ async function fetchJson<T>(url: string): Promise<T> {
       accept: "application/json",
     },
   });
+  const body = await response.text();
+  const contentType = response.headers.get("content-type") ?? "unknown content type";
 
   if (!response.ok) {
-    throw new Error(`${response.status} ${response.statusText}`);
+    throw new Error(`${response.status} ${response.statusText}: ${responseError(body)}`);
   }
 
-  return (await response.json()) as T;
+  if (!contentType.toLowerCase().includes("application/json")) {
+    throw new Error(`Expected JSON from ${url}, got ${contentType}: ${snippet(body)}`);
+  }
+
+  try {
+    return JSON.parse(body) as T;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON from ${url}: ${message}. Response: ${snippet(body)}`);
+  }
+}
+
+function responseError(body: string): string {
+  try {
+    const parsed = JSON.parse(body) as { error?: unknown; message?: unknown; details?: unknown };
+    const message = parsed.error || parsed.message || parsed.details;
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+  } catch {
+    // Fall back to the raw body below.
+  }
+
+  return snippet(body);
+}
+
+function snippet(value: string): string {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "empty response";
+  }
+
+  return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
 }

package/src/cli.ts

@@ -1,3 +1,4 @@
+import { readFile } from "node:fs/promises";
 import { difficultyLabels, domainLabels, focusSummary, skillLabels } from "./focus.ts";
 import { progressBarText } from "./progress.ts";
 import { buildSummaryRows, loadAttemptEvents, loadAttempts, loadFocus } from "./state.ts";
@@ -16,6 +17,7 @@ export type HistoryFilters = {
 export type ParsedCli =
   | { kind: "tui" }
   | { kind: "review" }
+  | { kind: "version" }
   | { kind: "help" }
   | { kind: "error"; message: string }
   | {
@@ -107,6 +109,10 @@ export function parseArgs(args: string[]): ParsedCli {
       return { kind: "help" };
     }
 
+    if (arg === "-V" || arg === "--version") {
+      return { kind: "version" };
+    }
+
     if (arg === "-p" || arg === "--pretty") {
       pretty = true;
       continue;
@@ -222,6 +228,11 @@ export async function runCliCommand(
     return 0;
   }
 
+  if (parsed.kind === "version") {
+    stdout.write(`sat ${await packageVersion()}\n`);
+    return 0;
+  }
+
   if (parsed.kind === "error") {
     stderr.write(`${parsed.message}\n\n${helpText()}\n`);
     return 1;
@@ -392,12 +403,19 @@ export function helpText(): string {
     "  -p, --pretty    Use colorized human-readable output",
     "      --json      Output JSON",
     "      --no-color  Disable ANSI color in pretty output",
+    "  -V, --version   Show version",
     "  -h, --help      Show this help",
     "",
     "Run `sat` with no command to open the interactive TUI.",
   ].join("\n");
 }
 
+async function packageVersion(): Promise<string> {
+  const packageJson = await readFile(new URL("../package.json", import.meta.url), "utf8");
+  const parsed = JSON.parse(packageJson) as { version?: unknown };
+  return typeof parsed.version === "string" && parsed.version ? parsed.version : "unknown";
+}
+
 export function filterHistory(attempts: Attempt[], filters: HistoryFilters = {}, now = new Date()): Attempt[] {
   let rows = [...attempts].sort((a, b) => b.updated_at.localeCompare(a.updated_at));
 

package/src/tui/question.ts

@@ -30,11 +30,11 @@ export function questionRows(detail: QuestionDetail, width: number): DisplayRow[
 }
 
 export function practiceQuestionUrl(question: PracticeQuestion): string {
-  return `https://practicesat.vercel.app/question?questionId=${encodeURIComponent(question.meta.questionId)}`;
+  return `https://mysatprep.fun/question/${encodeURIComponent(question.meta.questionId)}`;
 }
 
 export function practiceQuestionApiUrl(question: PracticeQuestion): string {
-  return `https://practicesat.vercel.app/api/question/${encodeURIComponent(question.meta.external_id)}`;
+  return `https://mysatprep.fun/api/question/${encodeURIComponent(question.meta.external_id)}`;
 }
 
 export function openExternalQuestion(question: PracticeQuestion): void {

package/.envrc

@@ -1 +0,0 @@
-use flake

package/AGENTS.md

@@ -1,37 +0,0 @@
-# Environment
-
-I use Nix & `direnv`. Glance `flake.nix` initially at once.
-
-# Git
-
-- Commit regularly.
-- Prefer subsystem-first commit subjects over Conventional Commits.
-  - Use `subsystem: concise change`.
-  - Do not default to `feat(...)`, `fix(...)`, `chore(...)`, etc.
-  - Pick the subsystem people would search for later: `cli`, `state`, `tui`, `api`, `docs`, `nix`, `test`, or a narrower module when useful.
-- Keep messages compact.
-  - A good small commit can be only a subject line.
-  - Add a body when the reason, tradeoff, or implementation detail matters.
-  - Body bullets should explain why/how, not repeat the subject.
-- Prefer backticks for paths, commands, package names, settings, and other literal identifiers when they improve scanability.
-
-```text
-cli: render activity as square heatmap
-
-- use one colored square per day instead of intensity glyphs
-- keep empty days visible as gray cells
-- orient the grid by week columns and weekday rows
-```
-
-```text
-state: record attempt events
-
-- keep `attempts.csv` as the latest per-question snapshot
-- append every answer to `events.csv` for streaks and activity
-```
-
-```text
-docs: tighten commit guidance
-```
-
-- Do not force a three-bullet format. Use fewer bullets, more bullets, or none based on the commit.

package/bun.lock

@@ -1,100 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "saterminal",
-      "dependencies": {
-        "he": "^1.2.0",
-        "node-html-parser": "^8.0.4",
-        "terminal-kit": "^3.1.2",
-        "word-wrap": "^1.2.5",
-      },
-      "devDependencies": {
-        "@types/bun": "^1.2.22",
-        "@types/he": "^1.2.3",
-        "@types/word-wrap": "^1.2.1",
-        "typescript": "^5.9.3",
-      },
-    },
-  },
-  "packages": {
-    "@cronvel/get-pixels": ["@cronvel/get-pixels@3.4.1", "", { "dependencies": { "jpeg-js": "^0.4.4", "ndarray": "^1.0.19", "ndarray-pack": "^1.1.1", "node-bitmap": "0.0.1", "omggif": "^1.0.10", "pngjs": "^6.0.0" } }, "sha512-gB5C5nDIacLUdsMuW8YsM9SzK3vaFANe4J11CVXpovpy7bZUGrcJKmc6m/0gWG789pKr6XSZY2aEetjFvSRw5g=="],
-
-    "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
-
-    "@types/he": ["@types/he@1.2.3", "", {}, "sha512-q67/qwlxblDzEDvzHhVkwc1gzVWxaNxeyHUBF4xElrvjL11O+Ytze+1fGpBHlr/H9myiBUaUXNnNPmBHxxfAcA=="],
-
-    "@types/node": ["@types/node@26.1.0", "", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-O0A1G3xPGy4w7AgQdAQYUlQ+BKk2Oovw8eRpofyp5KdBZULnbe+WqaOVNrm705SHphCiG4XHsACrSmPu1f+Kgw=="],
-
-    "@types/word-wrap": ["@types/word-wrap@1.2.1", "", { "dependencies": { "word-wrap": "*" } }, "sha512-McFkme6x07Y1LCGT5YJW1VN5+NTGcNe4IrJwKuQLObdxEIh57SIU+lIo2cF1/Z0XDJrjtXRoynn4HrvS6pO/8A=="],
-
-    "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
-
-    "bun-types": ["bun-types@1.3.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="],
-
-    "chroma-js": ["chroma-js@2.6.0", "", {}, "sha512-BLHvCB9s8Z1EV4ethr6xnkl/P2YRFOGqfgvuMG/MyCbZPrTA+NeiByY6XvgF0zP4/2deU2CXnWyMa3zu1LqQ3A=="],
-
-    "css-select": ["css-select@5.2.2", "", { "dependencies": { "boolbase": "^1.0.0", "css-what": "^6.1.0", "domhandler": "^5.0.2", "domutils": "^3.0.1", "nth-check": "^2.0.1" } }, "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw=="],
-
-    "css-what": ["css-what@6.2.2", "", {}, "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="],
-
-    "cwise-compiler": ["cwise-compiler@1.1.3", "", { "dependencies": { "uniq": "^1.0.0" } }, "sha512-WXlK/m+Di8DMMcCjcWr4i+XzcQra9eCdXIJrgh4TUgh0pIS/yJduLxS9JgefsHJ/YVLdgPtXm9r62W92MvanEQ=="],
-
-    "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
-
-    "domelementtype": ["domelementtype@2.3.0", "", {}, "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw=="],
-
-    "domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="],
-
-    "domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="],
-
-    "entities": ["entities@8.0.0", "", {}, "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA=="],
-
-    "he": ["he@1.2.0", "", { "bin": { "he": "bin/he" } }, "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="],
-
-    "iota-array": ["iota-array@1.0.0", "", {}, "sha512-pZ2xT+LOHckCatGQ3DcG/a+QuEqvoxqkiL7tvE8nn3uuu+f6i1TtpB5/FtWFbxUuVr5PZCx8KskuGatbJDXOWA=="],
-
-    "is-buffer": ["is-buffer@1.1.6", "", {}, "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w=="],
-
-    "jpeg-js": ["jpeg-js@0.4.4", "", {}, "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg=="],
-
-    "lazyness": ["lazyness@1.2.0", "", {}, "sha512-KenL6EFbwxBwRxG93t0gcUyi0Nw0Ub31FJKN1laA4UscdkL1K1AxUd0gYZdcLU3v+x+wcFi4uQKS5hL+fk500g=="],
-
-    "ndarray": ["ndarray@1.0.19", "", { "dependencies": { "iota-array": "^1.0.0", "is-buffer": "^1.0.2" } }, "sha512-B4JHA4vdyZU30ELBw3g7/p9bZupyew5a7tX1Y/gGeF2hafrPaQZhgrGQfsvgfYbgdFZjYwuEcnaobeM/WMW+HQ=="],
-
-    "ndarray-pack": ["ndarray-pack@1.2.1", "", { "dependencies": { "cwise-compiler": "^1.1.2", "ndarray": "^1.0.13" } }, "sha512-51cECUJMT0rUZNQa09EoKsnFeDL4x2dHRT0VR5U2H5ZgEcm95ZDWcMA5JShroXjHOejmAD/fg8+H+OvUnVXz2g=="],
-
-    "nextgen-events": ["nextgen-events@1.5.3", "", {}, "sha512-P6qw6kenNXP+J9XlKJNi/MNHUQ+Lx5K8FEcSfX7/w8KJdZan5+BB5MKzuNgL2RTjHG1Svg8SehfseVEp8zAqwA=="],
-
-    "node-bitmap": ["node-bitmap@0.0.1", "", {}, "sha512-Jx5lPaaLdIaOsj2mVLWMWulXF6GQVdyLvNSxmiYCvZ8Ma2hfKX0POoR2kgKOqz+oFsRreq0yYZjQ2wjE9VNzCA=="],
-
-    "node-html-parser": ["node-html-parser@8.0.4", "", { "dependencies": { "css-select": "^5.1.0", "entities": "^8.0.0" } }, "sha512-w2YxujN/TqrSIWGVNW/fVgKKfAyQeHMXCvnKZI0owLnfP0tfjdLecUoy9zhOMZGoEFk6eP5qSDyvUarjPl3bwQ=="],
-
-    "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
-
-    "omggif": ["omggif@1.0.10", "", {}, "sha512-LMJTtvgc/nugXj0Vcrrs68Mn2D1r0zf630VNtqtpI1FEO7e+O9FP4gqs9AcnBaSEeoHIPm28u6qgPR0oyEpGSw=="],
-
-    "pngjs": ["pngjs@6.0.0", "", {}, "sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg=="],
-
-    "setimmediate": ["setimmediate@1.0.5", "", {}, "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA=="],
-
-    "seventh": ["seventh@0.9.4", "", { "dependencies": { "setimmediate": "^1.0.5" } }, "sha512-O85mosi4sOfxG+slvqy0j7zLuFD4ylUgEMt7Pvt9Q/wnwNwG/6MNnHKzV9JkAoPoPM26t/DLFn17p7o7u5kIBA=="],
-
-    "string-kit": ["string-kit@0.19.5", "", {}, "sha512-MqNWtQQw6xMFbOSa26HfyS5uyDu1tR4OEPz44VDP6JWa/S0E0N11uw8CXrPt5hme/tBXRp5AmoIvFl5B9lt7PA=="],
-
-    "terminal-kit": ["terminal-kit@3.1.3", "", { "dependencies": { "@cronvel/get-pixels": "^3.4.1", "chroma-js": "^2.4.2", "lazyness": "^1.2.0", "ndarray": "^1.0.19", "nextgen-events": "^1.5.3", "seventh": "^0.9.4", "string-kit": "^0.19.5", "tree-kit": "^0.8.10" } }, "sha512-URPwQqXe/T5dZoD4qBHUO7eS+Vtf0PjliCftJU2EPaF5uVw/QG1zqgLy5kqwTrn1ix9e9HtMgMKAnzgaAnr3yA=="],
-
-    "tree-kit": ["tree-kit@0.8.10", "", {}, "sha512-mwuV3lHL+utI9z7vxah/27wrMJprx925xhkw1N4KuGa1dqIi0DLHWfXJpHEyR+ZI0Ij80zN58ztiGp3KlH0wtw=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@8.3.0", "", {}, "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ=="],
-
-    "uniq": ["uniq@1.0.1", "", {}, "sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA=="],
-
-    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
-
-    "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
-  }
-}

package/flake.lock

@@ -1,59 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1781577229,
-        "narHash": "sha256-lrp67w8AulE9Ks53n27I45ADSzbOCn4H+CNW1Ck8B+8=",
-        "rev": "567a49d1913ce81ac6e9582e3553dd90a955875f",
-        "revCount": 1017464,
-        "type": "tarball",
-        "url": "https://api.flakehub.com/f/pinned/DeterminateSystems/nixpkgs-weekly/0.1.1017464%2Brev-567a49d1913ce81ac6e9582e3553dd90a955875f/019f1749-32d6-7283-9e9a-861bd8478e6a/source.tar.gz"
-      },
-      "original": {
-        "type": "tarball",
-        "url": "https://flakehub.com/f/DeterminateSystems/nixpkgs-weekly/0.tar.gz"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

package/flake.nix

@@ -1,21 +0,0 @@
-{
-  inputs = {
-    nixpkgs.url = "https://flakehub.com/f/DeterminateSystems/nixpkgs-weekly/0.tar.gz";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { nixpkgs, flake-utils, ... }:
-    flake-utils.lib.eachDefaultSystem (
-      system:
-      let
-        pkgs = import nixpkgs { inherit system; };
-      in
-      {
-        devShells.default = pkgs.mkShell {
-          packages = with pkgs; [
-            bun
-          ];
-        };
-      }
-    );
-}

package/test/api.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { fetchQuestionBank } from "../src/api.ts";
-
-describe("api", () => {
-  test("passes excluded short question ids to the question bank endpoint", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank(["a", "b"]);
-      expect(requested).toContain("assessment=SAT");
-      expect(requested).toContain("excludeIds=a%2Cb");
-      expect(requested).toContain("difficulties=M%2CH");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("passes focus filters to the question bank endpoint", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank([], {
-        difficulties: ["H"],
-        domains: ["SEC"],
-        skills: ["BOU", "FSS"],
-      });
-      expect(requested).toContain("difficulties=H");
-      expect(requested).toContain("domains=SEC");
-      expect(requested).toContain("skills=BOU%2CFSS");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("derives domain filters from selected skill filters", async () => {
-    const originalFetch = globalThis.fetch;
-    let requested = "";
-    globalThis.fetch = ((input: RequestInfo | URL) => {
-      requested = String(input);
-      return Promise.resolve(
-        new Response(JSON.stringify({ success: true, data: [] }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }),
-      );
-    }) as typeof fetch;
-
-    try {
-      await fetchQuestionBank([], {
-        difficulties: ["H"],
-        domains: ["INI"],
-        skills: ["WIC"],
-      });
-      expect(requested).toContain("domains=CAS");
-      expect(requested).toContain("skills=WIC");
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-});

package/test/cli.test.ts

@@ -1,223 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { defaultFocus } from "../src/focus.ts";
-import {
-  formatFocus,
-  formatHistory,
-  formatStats,
-  formatWeak,
-  parseArgs,
-} from "../src/cli.ts";
-import { buildSummaryRows, recordAttempt } from "../src/state.ts";
-import type { AttemptEvent, Focus, QuestionMeta } from "../src/types.ts";
-
-describe("cli", () => {
-  test("uses subcommands for report selection and flags for format", () => {
-    expect(parseArgs([])).toEqual({ kind: "tui" });
-    expect(parseArgs(["history"])).toEqual({ kind: "command", command: "history", format: "text" });
-    expect(parseArgs(["history", "-p"])).toEqual({ kind: "command", command: "history", format: "pretty" });
-    expect(parseArgs(["--json", "stats"])).toEqual({ kind: "command", command: "stats", format: "json" });
-    expect(parseArgs(["weak", "--pretty", "--no-color"])).toEqual({ kind: "command", command: "weak", format: "pretty", color: false });
-    expect(parseArgs(["review"])).toEqual({ kind: "review" });
-    expect(parseArgs(["--history"])).toEqual({ kind: "error", message: "Unknown option: --history" });
-  });
-
-  test("rejects conflicting output format flags", () => {
-    expect(parseArgs(["focus", "--json", "--pretty"])).toEqual({
-      kind: "error",
-      message: "Choose either `--pretty` or `--json`, not both.",
-    });
-  });
-
-  test("parses and applies history filters", () => {
-    expect(parseArgs(["history", "--wrong", "--corrected", "--limit", "5", "--since=7d"])).toEqual({
-      kind: "command",
-      command: "history",
-      format: "text",
-      filters: { wrong: true, corrected: true, limit: 5, since: "7d" },
-    });
-    expect(parseArgs(["stats", "--wrong"])).toEqual({
-      kind: "error",
-      message: "History filters only work with `sat history`.",
-    });
-
-    const attempts = new Map();
-    recordAttempt(attempts, "old", false, 10, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "wrong", false, 20, new Date("2026-01-08T00:00:00.000Z"));
-    recordAttempt(attempts, "fixed", false, 30, new Date("2026-01-08T00:00:00.000Z"));
-    recordAttempt(attempts, "fixed", true, 40, new Date("2026-01-09T00:00:00.000Z"));
-
-    expect(JSON.parse(formatHistory([...attempts.values()], "json", { filters: { wrong: true }, now: new Date("2026-01-10T00:00:00.000Z") }))).toEqual([
-      {
-        question_id: "wrong",
-        outcome: "incorrect",
-        updated_at: "2026-01-08T00:00:00.000Z",
-        elapsed_seconds: 20,
-      },
-      {
-        question_id: "old",
-        outcome: "incorrect",
-        updated_at: "2026-01-01T00:00:00.000Z",
-        elapsed_seconds: 10,
-      },
-    ]);
-    expect(JSON.parse(formatHistory([...attempts.values()], "json", {
-      filters: { corrected: true, since: "7d", limit: 1 },
-      now: new Date("2026-01-10T00:00:00.000Z"),
-    }))).toEqual([
-      {
-        question_id: "fixed",
-        outcome: "corrected",
-        updated_at: "2026-01-09T00:00:00.000Z",
-        elapsed_seconds: 40,
-      },
-    ]);
-  });
-
-  test("formats history as sorted JSON and pretty table output", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "older", false, 65, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "newer", true, 5, new Date("2026-01-02T00:00:00.000Z"));
-
-    expect(JSON.parse(formatHistory([...attempts.values()], "json"))).toEqual([
-      {
-        question_id: "newer",
-        outcome: "correct",
-        updated_at: "2026-01-02T00:00:00.000Z",
-        elapsed_seconds: 5,
-      },
-      {
-        question_id: "older",
-        outcome: "incorrect",
-        updated_at: "2026-01-01T00:00:00.000Z",
-        elapsed_seconds: 65,
-      },
-    ]);
-
-    const pretty = formatHistory([...attempts.values()], "pretty");
-    expect(pretty).toContain("\x1b[");
-    expect(stripAnsi(pretty)).toContain("history\n2 attempts  1 mastered  1 needs review");
-    expect(stripAnsi(pretty)).toContain("newer");
-    expect(stripAnsi(pretty)).toContain("correct");
-    expect(stripAnsi(pretty)).toContain("1:05");
-  });
-
-  test("formats stats with numeric JSON and human percentages", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "a", true, 20, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "b", false, 40, new Date("2026-01-01T00:00:00.000Z"));
-    const rows = buildSummaryRows(attempts, new Date("2026-01-02T00:00:00.000Z"));
-
-    expect(JSON.parse(formatStats(rows, "json"))).toEqual({
-      answered: 2,
-      correct: 1,
-      incorrect: 1,
-      corrected: 0,
-      accuracy: 0.5,
-      avg_seconds: 30,
-    });
-    const pretty = formatStats(rows, "pretty");
-    expect(pretty).toContain("\x1b[");
-    expect(stripAnsi(pretty)).toContain("stats\n2 answered  50% accuracy  0:30 avg");
-    expect(stripAnsi(pretty)).toContain("correct     1");
-    expect(stripAnsi(pretty)).toContain("incorrect   1");
-    expect(pretty).toContain("\x1b[42m            \x1b[0m\x1b[100m            \x1b[0m");
-    expect(stripAnsi(pretty)).not.toContain("#");
-    expect(stripAnsi(pretty)).not.toContain("░");
-    expect(formatStats(rows, "text")).toContain("avg seconds  30.0s");
-
-    const noColor = formatStats(rows, "pretty", { color: false });
-    expect(noColor).not.toContain("\x1b[");
-    expect(noColor).toContain("[████████████            ]");
-  });
-
-  test("formats stats with streak and activity when events are available", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "a", true, 20, new Date("2026-01-09T12:00:00"));
-    const rows = buildSummaryRows(attempts, new Date("2026-01-10T12:00:00"));
-    const events: AttemptEvent[] = [
-      attemptEvent("a", true, "2026-01-08T12:00:00"),
-      attemptEvent("b", false, "2026-01-09T12:00:00"),
-    ];
-
-    expect(JSON.parse(formatStats(rows, "json", { events, now: new Date("2026-01-10T12:00:00") })).activity).toMatchObject({
-      streak: 2,
-      activeDays: 2,
-      todayCount: 0,
-      totalEvents: 2,
-    });
-
-    const rawPretty = formatStats(rows, "pretty", { events, now: new Date("2026-01-10T12:00:00") });
-    const pretty = stripAnsi(rawPretty);
-    expect(pretty).toContain("2 day streak");
-    expect(pretty).toContain("activity\nlast 12 weeks");
-    expect(pretty).toContain("Mon");
-    expect(pretty).toContain("Wed");
-    expect(pretty).toContain("Fri");
-    expect(pretty).toContain("Oct");
-    expect(pretty).toContain("Jan");
-    expect(rawPretty).toContain("\x1b[38;5;238m■\x1b[0m");
-    expect(rawPretty).toContain("\x1b[38;5;22m■\x1b[0m");
-    expect(rawPretty).not.toContain("·");
-  });
-
-  test("formats focus as raw selections or labeled pretty output", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-
-    expect(formatFocus(focus, "json")).toBe(JSON.stringify(focus));
-    expect(formatFocus(focus, "text")).toBe("difficulties: H\ndomains: CAS\nskills: WIC");
-    expect(formatFocus(focus, "pretty")).toContain("\x1b[");
-    expect(stripAnsi(formatFocus(focus, "pretty"))).toContain("H   Hard");
-    expect(stripAnsi(formatFocus(defaultFocus, "pretty"))).toContain("10 skills");
-  });
-
-  test("formats weak spots from metadata-backed attempts", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "wic1", false, 50, new Date("2026-01-01T00:00:00.000Z"), sampleMeta);
-    recordAttempt(
-      attempts,
-      "ctc1",
-      true,
-      20,
-      new Date("2026-01-02T00:00:00.000Z"),
-      { ...sampleMeta, questionId: "ctc1", skill_cd: "CTC", skill_desc: "Cross-Text Connections" },
-    );
-
-    expect(JSON.parse(formatWeak([...attempts.values()], "json"))[0]).toMatchObject({
-      skill: "WIC",
-      missed: 1,
-      total: 1,
-      accuracy: 0,
-    });
-    expect(formatWeak([...attempts.values()], "text")).toContain("WIC    0%");
-    expect(stripAnsi(formatWeak([...attempts.values()], "pretty"))).toContain("weak spots\nWIC has 1 misses");
-  });
-});
-
-function stripAnsi(value: string): string {
-  return value.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
-function attemptEvent(questionId: string, correct: boolean, answeredAt: string): AttemptEvent {
-  return {
-    question_id: questionId,
-    correct,
-    answered_at: answeredAt,
-    elapsed_seconds: 20,
-    difficulty: "M",
-    domain: "CAS",
-    domain_desc: "Craft and Structure",
-    skill: "WIC",
-    skill_desc: "Words in Context",
-  };
-}
-
-const sampleMeta: QuestionMeta = {
-  questionId: "wic1",
-  uId: "wic1",
-  external_id: "external-1",
-  difficulty: "M",
-  primary_class_cd: "CAS",
-  primary_class_cd_desc: "Craft and Structure",
-  skill_cd: "WIC",
-  skill_desc: "Words in Context",
-};

package/test/focus.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { focusRows, toggleFocusRow } from "../src/focus.ts";
-import { focusGrid, moveFocusGridPosition, toggleFocusGridRow } from "../src/tui/focus-grid.ts";
-import type { Focus } from "../src/types.ts";
-
-describe("focus", () => {
-  test("renders skills as nested domain children", () => {
-    const rows = focusRows({ difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] });
-    const cas = rows.find((row) => row.kind === "option" && row.value === "CAS");
-    const wic = rows.find((row) => row.kind === "option" && row.value === "WIC");
-
-    expect(cas).toMatchObject({ kind: "option", checked: true, partial: true, depth: 0 });
-    expect(wic).toMatchObject({ kind: "option", checked: true, depth: 1 });
-  });
-
-  test("domain toggles operate on their child skills", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-    const cas = focusRows(focus).find((row) => row.kind === "option" && row.value === "CAS");
-
-    expect(toggleFocusRow(focus, cas)).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC", "TSP", "CTC"],
-    });
-  });
-
-  test("grid navigation moves predictably across columns and rows", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-    const columns = focusGrid(focus);
-
-    expect(moveFocusGridPosition(columns, { column: 0, row: 1 }, "down")).toEqual({ column: 0, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "down")).toEqual({ column: 0, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "next")).toEqual({ column: 1, row: 2 });
-    expect(moveFocusGridPosition(columns, { column: 0, row: 2 }, "previous")).toEqual({ column: 4, row: 2 });
-  });
-
-  test("grid navigation clamps row when moving into shorter columns", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["INI"], skills: ["CID", "INF", "COE"] };
-    const columns = focusGrid(focus);
-
-    expect(moveFocusGridPosition(columns, { column: 1, row: 3 }, "next")).toEqual({ column: 2, row: 3 });
-    expect(moveFocusGridPosition(columns, { column: 2, row: 3 }, "next")).toEqual({ column: 3, row: 2 });
-  });
-
-  test("grid toggles use focus constraints", () => {
-    const focus: Focus = { difficulties: ["H"], domains: ["CAS"], skills: ["WIC"] };
-
-    expect(toggleFocusGridRow(focus, { column: 0, row: 2 })).toBe(focus);
-    expect(toggleFocusGridRow(focus, { column: 2, row: 0 })).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC", "TSP", "CTC"],
-    });
-  });
-});

package/test/frame.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Frame, FrameRenderer, type FrameOutput, type TextAttr } from "../src/tui/frame.ts";
-
-class RecordingOutput implements FrameOutput {
-  ops: string[] = [];
-
-  clear(): void {
-    this.ops.push("clear");
-  }
-
-  moveTo(x: number, y: number): void {
-    this.ops.push(`move:${x},${y}`);
-  }
-
-  eraseLineAfter(): void {
-    this.ops.push("erase");
-  }
-
-  reset(): void {
-    this.ops.push("reset");
-  }
-
-  write(value: string, attr: TextAttr = {}): void {
-    const color = typeof attr.color === "string" ? attr.color : "default";
-    const bold = attr.bold ? ":bold" : "";
-    this.ops.push(`write:${color}${bold}:${value}`);
-  }
-}
-
-describe("frame renderer", () => {
-  test("clips and truncates writes inside frame bounds", () => {
-    const frame = new Frame(6, 2);
-
-    frame.writeText(2, 0, "abcdef", { color: "cyan" }, 4);
-    frame.writeText(-1, 1, "xyz", { color: "red" });
-    frame.writeText(0, 5, "ignored");
-
-    expect(frame.rowRuns(0)).toEqual([{ x: 2, text: "abc…", attr: { color: "cyan" } }]);
-    expect(frame.rowRuns(1)).toEqual([{ x: 0, text: "yz", attr: { color: "red" } }]);
-  });
-
-  test("emits no operations when the next frame is unchanged", () => {
-    const output = new RecordingOutput();
-    const renderer = new FrameRenderer(output);
-    const frame = new Frame(10, 3);
-    frame.writeText(0, 0, "sat", { bold: true });
-
-    renderer.draw(frame);
-    output.ops = [];
-    renderer.draw(frame);
-
-    expect(output.ops).toEqual([]);
-  });
-
-  test("only repaints rows whose rendered content changed", () => {
-    const output = new RecordingOutput();
-    const renderer = new FrameRenderer(output);
-    const first = new Frame(20, 3);
-    first.writeText(0, 0, "sat", { bold: true });
-    first.writeText(0, 1, "----------", { color: "gray" });
-    renderer.draw(first);
-
-    output.ops = [];
-    const second = new Frame(20, 3);
-    second.writeText(0, 0, "sat", { bold: true });
-    second.writeText(0, 1, "----------", { color: "gray" });
-    second.writeText(7, 0, "time 0:02", { color: "gray" });
-    renderer.draw(second);
-
-    expect(output.ops).toEqual([
-      "move:1,1",
-      "reset",
-      "erase",
-      "move:1,1",
-      "write:default:bold:sat",
-      "move:8,1",
-      "write:gray:time 0:02",
-      "reset",
-    ]);
-  });
-
-  test("clears a row when content is removed", () => {
-    const output = new RecordingOutput();
-    const renderer = new FrameRenderer(output);
-    const first = new Frame(20, 2);
-    first.writeText(0, 0, "temporary");
-    renderer.draw(first);
-
-    output.ops = [];
-    renderer.draw(new Frame(20, 2));
-
-    expect(output.ops).toEqual(["move:1,1", "reset", "erase", "reset"]);
-  });
-});

package/test/progress.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { progressBarText } from "../src/progress.ts";
-
-describe("progress", () => {
-  test("renders a block progress bar with empty cells", () => {
-    expect(progressBarText(0.5, 8)).toBe("████    ");
-  });
-
-  test("uses partial block cells for fractional progress", () => {
-    expect(progressBarText(0.3125, 8)).toBe("██▌     ");
-  });
-
-  test("clamps invalid ratios", () => {
-    expect(progressBarText(-1, 4)).toBe("    ");
-    expect(progressBarText(2, 4)).toBe("████");
-    expect(progressBarText(Number.NaN, 4)).toBe("    ");
-  });
-});

package/test/state.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { defaultFocus, normalizeFocus } from "../src/focus.ts";
-import {
-  buildSummaryRows,
-  displayStateDir,
-  appendAttemptEvent,
-  loadAttemptEvents,
-  loadAttempts,
-  loadFocus,
-  nextOutcome,
-  recordAttempt,
-  resolveStateDir,
-  saveAttempts,
-  saveFocus,
-  stateDirExists,
-} from "../src/state.ts";
-import type { QuestionMeta } from "../src/types.ts";
-
-describe("state", () => {
-  test("resolves state dir under the user home directory", () => {
-    expect(resolveStateDir("/home/user")).toBe("/home/user/.saterminal/userlocal");
-  });
-
-  test("displays state dir with a tilde prefix", () => {
-    expect(displayStateDir("/home/user/.saterminal/userlocal", "/home/user")).toBe("~/.saterminal/userlocal");
-    expect(displayStateDir("/home/user", "/home/user")).toBe("~");
-  });
-
-  test("detects whether the state directory exists", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-
-    try {
-      expect(await stateDirExists(dir)).toBe(true);
-      expect(await stateDirExists(join(dir, "missing"))).toBe(false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("creates and reads a compact attempts csv", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "attempts.csv");
-
-    try {
-      const attempts = await loadAttempts(path);
-      recordAttempt(attempts, "abc12345", false, 42, new Date("2026-01-01T00:00:00.000Z"), sampleMeta);
-      await saveAttempts(attempts, path);
-
-      const raw = await readFile(path, "utf8");
-      expect(raw).toBe(
-        [
-          "question_id,outcome,updated_at,elapsed_seconds,difficulty,domain,domain_desc,skill,skill_desc",
-          "abc12345,incorrect,2026-01-01T00:00:00.000Z,42,H,CAS,Craft and Structure,WIC,Words in Context",
-          "",
-        ].join("\n"),
-      );
-      expect(await loadAttempts(path)).toEqual(attempts);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("uses corrected for a later right answer after a miss", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "abc12345", false, 12, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "abc12345", true, 10, new Date("2026-01-02T00:00:00.000Z"));
-
-    expect(attempts.get("abc12345")?.outcome).toBe("corrected");
-  });
-
-  test("loads escaped csv fields", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "attempts.csv");
-
-    try {
-      await writeFile(
-        path,
-        [
-          "question_id,outcome,updated_at,elapsed_seconds,difficulty,domain,domain_desc,skill,skill_desc",
-          "\"abc,123\",correct,\"2026-01-01T00:00:00.000Z\",12,M,INI,\"Information, Ideas\",CID,Central Ideas",
-          "",
-        ].join("\n"),
-        "utf8",
-      );
-
-      expect(await loadAttempts(path)).toEqual(new Map([
-        ["abc,123", {
-          question_id: "abc,123",
-          outcome: "correct",
-          updated_at: "2026-01-01T00:00:00.000Z",
-          elapsed_seconds: 12,
-          difficulty: "M",
-          domain: "INI",
-          domain_desc: "Information, Ideas",
-          skill: "CID",
-          skill_desc: "Central Ideas",
-        }],
-      ]));
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("does not downgrade mastered outcomes", () => {
-    expect(nextOutcome("correct", false)).toBe("correct");
-    expect(nextOutcome("corrected", false)).toBe("corrected");
-  });
-
-  test("builds summary rows from attempts", () => {
-    const attempts = new Map();
-    recordAttempt(attempts, "a", true, 20, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "b", false, 10, new Date("2026-01-01T00:00:00.000Z"));
-    recordAttempt(attempts, "b", true, 40, new Date("2026-01-02T00:00:00.000Z"));
-
-    const rows = buildSummaryRows(attempts, new Date("2026-01-03T00:00:00.000Z"));
-    expect(Object.fromEntries(rows.map((row) => [row.metric, row.value]))).toEqual({
-      answered: "2",
-      correct: "1",
-      incorrect: "0",
-      corrected: "1",
-      accuracy: "1.00",
-      avg_seconds: "30.0",
-    });
-  });
-
-  test("appends and loads attempt events", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "events.csv");
-
-    try {
-      await appendAttemptEvent(sampleMeta, true, 31, new Date("2026-01-01T12:00:00.000Z"), path);
-      await appendAttemptEvent(
-        { ...sampleMeta, questionId: "def67890", skill_cd: "CTC", skill_desc: "Cross-Text Connections" },
-        false,
-        44,
-        new Date("2026-01-02T12:00:00.000Z"),
-        path,
-      );
-
-      expect(await loadAttemptEvents(path)).toEqual([
-        {
-          question_id: "abc12345",
-          correct: true,
-          answered_at: "2026-01-01T12:00:00.000Z",
-          elapsed_seconds: 31,
-          difficulty: "H",
-          domain: "CAS",
-          domain_desc: "Craft and Structure",
-          skill: "WIC",
-          skill_desc: "Words in Context",
-        },
-        {
-          question_id: "def67890",
-          correct: false,
-          answered_at: "2026-01-02T12:00:00.000Z",
-          elapsed_seconds: 44,
-          difficulty: "H",
-          domain: "CAS",
-          domain_desc: "Craft and Structure",
-          skill: "CTC",
-          skill_desc: "Cross-Text Connections",
-        },
-      ]);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("normalizes invalid focus selections to valid defaults", () => {
-    expect(normalizeFocus({ difficulties: [], domains: ["NOPE"], skills: ["CID"] })).toEqual({
-      difficulties: defaultFocus.difficulties,
-      domains: ["INI"],
-      skills: ["CID"],
-    });
-  });
-
-  test("derives focus domains from selected skills", () => {
-    expect(normalizeFocus({ difficulties: ["H"], domains: ["INI"], skills: ["WIC"] })).toEqual({
-      difficulties: ["H"],
-      domains: ["CAS"],
-      skills: ["WIC"],
-    });
-  });
-
-  test("creates default focus when file is missing", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      expect(await loadFocus(path)).toEqual(defaultFocus);
-      expect(await readFile(path, "utf8")).toContain("\"difficulties\"");
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("saves and loads focus json", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      await saveFocus({ difficulties: ["H"], domains: ["SEC"], skills: ["BOU", "FSS"] }, path);
-      expect(await loadFocus(path)).toEqual({ difficulties: ["H"], domains: ["SEC"], skills: ["BOU", "FSS"] });
-
-      await writeFile(path, "{\"difficulties\":[],\"domains\":[],\"skills\":[]}", "utf8");
-      expect(await loadFocus(path)).toEqual(defaultFocus);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("throws when focus json is invalid", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "saterminal-"));
-    const path = join(dir, "focus.json");
-
-    try {
-      await writeFile(path, "{not json", "utf8");
-      await expect(loadFocus(path)).rejects.toThrow(/Invalid focus file/);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-const sampleMeta: QuestionMeta = {
-  questionId: "abc12345",
-  uId: "abc12345",
-  external_id: "external-1",
-  difficulty: "H",
-  primary_class_cd: "CAS",
-  primary_class_cd_desc: "Craft and Structure",
-  skill_cd: "WIC",
-  skill_desc: "Words in Context",
-};

package/test/text.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { hasHtmlTable, htmlToText, parseHtmlSegments, wrapSegments, wrapText } from "../src/text.ts";
-
-describe("text", () => {
-  test("converts the API html subset into terminal text", () => {
-    expect(htmlToText("<p><strong>Text 1</strong></p><p>Alice&rsquo;s claim&mdash;briefly.</p>")).toBe(
-      "Text 1\nAlice's claim-briefly.",
-    );
-  });
-
-  test("uses media labels instead of leaking svg internals", () => {
-    expect(
-      htmlToText(
-        '<figure><svg aria-label="Line graph titled Exports"><text>90807060</text></svg></figure><p>Read the graph.</p>',
-      ),
-    ).toBe("[Graph: Line graph titled Exports]\nRead the graph.");
-  });
-
-  test("keeps image alt text visible", () => {
-    expect(htmlToText('<p><img alt="Triangle ABC" src="/triangle.png"></p>')).toBe("[Image: Triangle ABC]");
-  });
-
-  test("detects html tables", () => {
-    expect(hasHtmlTable("<p>Text</p>", "<table><tr><td>1</td></tr></table>")).toBe(true);
-    expect(hasHtmlTable("<p>Text</p>")).toBe(false);
-  });
-
-  test("normalizes SAT blank markers", () => {
-    expect(htmlToText("<p>The answer is ______blank because of the data.</p>")).toBe(
-      "The answer is _______ because of the data.",
-    );
-  });
-
-  test("wraps text without dropping words", () => {
-    expect(wrapText("one two three four", 8)).toEqual(["one two", "three", "four"]);
-  });
-
-  test("preserves underline segments from u tags", () => {
-    const segments = parseHtmlSegments("<p>Before <u>underlined claim</u> after.</p>");
-    expect(segments.some((segment) => segment.style.underline && segment.text.includes("underlined claim"))).toBe(true);
-    expect(htmlToText("<p>Before <u>underlined claim</u> after.</p>")).toBe("Before underlined claim after.");
-  });
-
-  test("normalizes API blank spans in parsed segments", () => {
-    const html =
-      '<p>The answer is <span aria-hidden="true">______</span><span class="sr-only">blank</span> because of the data.</p>';
-    const text = parseHtmlSegments(html)
-      .map((segment) => segment.text)
-      .join("")
-      .trim();
-    expect(text).toBe("The answer is _______ because of the data.");
-  });
-
-  test("wraps styled segments without losing underline spans", () => {
-    const segments = parseHtmlSegments("<u>This insightful depiction of a preteen girl</u>");
-    const lines = wrapSegments(segments, 20);
-    expect(lines.flat().some((segment) => segment.style.underline)).toBe(true);
-  });
-
-  test("collapses spacer paragraphs and decodes accented entities in dual-text stimuli", () => {
-    const html = `<p><strong><span role="heading">Text 1</span></strong></p>
-<p>the object that struck the Yucat&aacute;n Peninsula</p>
-<p>&nbsp;</p>
-<p><strong><span role="heading">Text 2</span></strong></p>
-<p>Artemieva argues that an asteroid is plausible.</p>`;
-    const lines = wrapSegments(parseHtmlSegments(html), 40).map((line) => line.map((segment) => segment.text).join(""));
-    const blankLines = lines.filter((line) => !line.trim()).length;
-    expect(blankLines).toBeLessThanOrEqual(2);
-    expect(lines.join("\n")).toContain("Yucatán");
-    expect(lines.join("\n")).not.toContain("&aacute;");
-  });
-});

package/test/viewport.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  clampScroll,
-  ensureRangeVisible,
-  ensureRowVisible,
-  maxScroll,
-  scrollBy,
-  scrollPage,
-  scrollToEdge,
-} from "../src/tui/viewport.ts";
-
-describe("viewport", () => {
-  test("clamps scroll to the available content", () => {
-    expect(maxScroll({ scroll: 0, height: 5, contentRows: 12 })).toBe(7);
-    expect(clampScroll({ scroll: -3, height: 5, contentRows: 12 })).toBe(0);
-    expect(clampScroll({ scroll: 20, height: 5, contentRows: 12 })).toBe(7);
-    expect(clampScroll({ scroll: 20, height: 5, contentRows: 3 })).toBe(0);
-  });
-
-  test("scrolls by lines and pages", () => {
-    const viewport = { scroll: 4, height: 5, contentRows: 20 };
-
-    expect(scrollBy(viewport, 2)).toBe(6);
-    expect(scrollBy(viewport, -10)).toBe(0);
-    expect(scrollPage(viewport, 1)).toBe(8);
-    expect(scrollPage(viewport, -1)).toBe(0);
-    expect(scrollToEdge(viewport, "bottom")).toBe(15);
-  });
-
-  test("keeps a selected row or wrapped range visible", () => {
-    const viewport = { scroll: 4, height: 5, contentRows: 20 };
-
-    expect(ensureRowVisible(viewport, 3)).toBe(3);
-    expect(ensureRowVisible(viewport, 8)).toBe(4);
-    expect(ensureRowVisible(viewport, 12)).toBe(8);
-    expect(ensureRangeVisible(viewport, 11, 13)).toBe(9);
-    expect(ensureRangeVisible(viewport, 5, 7)).toBe(4);
-  });
-});

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "skipLibCheck": true,
-    "types": ["bun"],
-    "allowImportingTsExtensions": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*.ts", "src/**/*.d.ts", "test/**/*.ts"]
-}