saterminal 0.1.0

package/.envrc

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

package/AGENTS.md

@@ -0,0 +1,23 @@
+# Git
+
+- Commit regularly.
+- Commit messages should split "what" from "why/how":
+  - First line: conventional commit summary.
+  - Following lines: concise reasons and implementation notes.
+- Prefer backticks for paths, commands, package names, settings, and other literal identifiers that are easier to recognize that way.
+
+```text
+feat(darwin/packages): add `btop` and `macmon`
+
+- `btop` and `macmon` provide terminal-based system monitoring
+- install them through `environment.systemPackages` so they are available system-wide
+- both packages resolve from the pinned nixpkgs set, so no unstable package source is needed
+```
+
+```text
+chore(repo): remove unused `documents/` directory
+
+- no Nix modules, package config, or templates reference `documents/`
+- the directory only contained standalone agent/document notes
+- removing it keeps the repo focused on active configuration
+```

package/README.md

@@ -0,0 +1,4 @@
+why?
+
+- i don't like how the official SAT question bank forces u to download PDFs
+- official SAT question bank + other third party question readers display the question difficulty and other metadata

package/bun.lock

@@ -0,0 +1,100 @@
+{
+  "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

@@ -0,0 +1,59 @@
+{
+  "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

@@ -0,0 +1,21 @@
+{
+  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/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "saterminal",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "sat": "./src/main.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/main.ts",
+    "start": "bun run src/main.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "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"
+  }
+}

package/src/api.ts

@@ -0,0 +1,78 @@
+import { defaultFocus, domainsForSkills } from "./focus.ts";
+import type { Focus, PracticeQuestion, QuestionDetail, QuestionMeta } from "./types.ts";
+
+const baseUrl = "https://practicesat.vercel.app/api";
+
+type ApiEnvelope<T> = {
+  success: boolean;
+  data: T;
+  message?: string;
+};
+
+export async function fetchQuestionBank(excludeIds: Iterable<string> = [], focus: Focus = defaultFocus): Promise<QuestionMeta[]> {
+  const params = focusParams(focus);
+  const excluded = [...excludeIds].filter(Boolean);
+  if (excluded.length > 0) {
+    params.set("excludeIds", excluded.join(","));
+  }
+
+  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.");
+  }
+
+  return response.data.filter((item) => item.questionId && item.external_id);
+}
+
+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.`);
+  }
+
+  return response.data;
+}
+
+export async function fetchPracticeQuestion(attemptedIds: Iterable<string>, focus: Focus = defaultFocus): Promise<PracticeQuestion> {
+  const bank = await fetchQuestionBank(attemptedIds, focus);
+  if (bank.length === 0) {
+    throw new Error("No unanswered questions matched the current filters.");
+  }
+
+  const meta = bank[Math.floor(Math.random() * bank.length)];
+  const detail = await fetchQuestion(meta.external_id);
+  return { meta, detail };
+}
+
+export async function findQuestionByShortId(questionId: string): Promise<PracticeQuestion | undefined> {
+  const bank = await fetchQuestionBank();
+  const meta = bank.find((item) => item.questionId === questionId);
+  if (!meta) {
+    return undefined;
+  }
+
+  return { meta, detail: await fetchQuestion(meta.external_id) };
+}
+
+function focusParams(focus: Focus): URLSearchParams {
+  return new URLSearchParams({
+    assessment: "SAT",
+    domains: domainsForSkills(focus.skills).join(","),
+    difficulties: focus.difficulties.join(","),
+    skills: focus.skills.join(","),
+  });
+}
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+
+  return (await response.json()) as T;
+}

package/src/focus.ts

@@ -0,0 +1,231 @@
+import type { Difficulty, Domain, Focus, Skill } from "./types.ts";
+
+export const difficultyOptions = ["E", "M", "H"] as const satisfies readonly Difficulty[];
+export const domainOptions = ["INI", "CAS", "EOI", "SEC"] as const satisfies readonly Domain[];
+export const skillOptions = ["CID", "INF", "COE", "WIC", "TSP", "CTC", "SYN", "TRA", "BOU", "FSS"] as const satisfies readonly Skill[];
+
+export const skillsByDomain: Record<Domain, readonly Skill[]> = {
+  INI: ["CID", "INF", "COE"],
+  CAS: ["WIC", "TSP", "CTC"],
+  EOI: ["SYN", "TRA"],
+  SEC: ["BOU", "FSS"],
+};
+
+export const defaultFocus: Focus = {
+  difficulties: ["M", "H"],
+  domains: [...domainOptions],
+  skills: [...skillOptions],
+};
+
+export type FocusGroup = "difficulties" | "domains" | "skills";
+
+export type FocusRow =
+  | { kind: "header"; label: string }
+  | {
+    kind: "option";
+    group: FocusGroup;
+    value: Difficulty | Domain | Skill;
+    label: string;
+    checked: boolean;
+    partial?: boolean;
+    depth: number;
+  };
+
+export function normalizeFocus(value: unknown): Focus {
+  const raw = value && typeof value === "object" ? value as Partial<Record<keyof Focus, unknown>> : {};
+  const skills = normalizeSkills(raw.skills, raw.domains);
+  return {
+    difficulties: normalizeSelection(raw.difficulties, difficultyOptions, defaultFocus.difficulties),
+    domains: domainsForSkills(skills),
+    skills,
+  };
+}
+
+export function domainsForSkills(skills: readonly Skill[]): Domain[] {
+  return domainOptions.filter((domain) => skillsForDomain(domain).some((skill) => skills.includes(skill)));
+}
+
+export function skillsForDomain(domain: Domain): readonly Skill[] {
+  return skillsByDomain[domain];
+}
+
+export function focusSummary(focus: Focus): string {
+  const difficulty = focus.difficulties.join(",");
+  const skillCount = focus.skills.length;
+  const domainCount = focus.domains.length;
+  return `${skillCount} skills · ${difficulty} · ${domainCount} domains`;
+}
+
+export function focusRows(focus: Focus): FocusRow[] {
+  return [
+    { kind: "header", label: "Difficulty" },
+    ...difficultyOptions.map((value) => optionRow("difficulties", value, difficultyLabels[value], focus.difficulties.includes(value), 0)),
+    { kind: "header", label: "Reading and Writing" },
+    ...domainOptions.flatMap((domain) => domainRows(domain, focus)),
+  ];
+}
+
+export function toggleFocusRow(focus: Focus, row: FocusRow | undefined): Focus {
+  if (!row || row.kind !== "option") {
+    return focus;
+  }
+
+  if (row.group === "domains") {
+    return toggleDomainFocus(focus, row.value as Domain);
+  }
+
+  if (row.group === "difficulties") {
+    return toggleDifficultyFocus(focus, row.value as Difficulty);
+  }
+
+  return toggleSkillFocus(focus, row.value as Skill);
+}
+
+export function nextFocusableIndex(rows: FocusRow[], current: number): number {
+  for (let index = Math.min(current + 1, rows.length - 1); index < rows.length; index++) {
+    if (rows[index]?.kind === "option") {
+      return index;
+    }
+  }
+  return current;
+}
+
+export function previousFocusableIndex(rows: FocusRow[], current: number): number {
+  for (let index = Math.max(current - 1, 0); index >= 0; index--) {
+    if (rows[index]?.kind === "option") {
+      return index;
+    }
+  }
+  return current;
+}
+
+function domainRows(domain: Domain, focus: Focus): FocusRow[] {
+  const skills = skillsForDomain(domain);
+  const selected = skills.filter((skill) => focus.skills.includes(skill));
+  return [
+    optionRow("domains", domain, domainLabels[domain], selected.length > 0, 0, selected.length > 0 && selected.length < skills.length),
+    ...skills.map((skill) => optionRow("skills", skill, skillLabels[skill], focus.skills.includes(skill), 1)),
+  ];
+}
+
+function optionRow(
+  group: FocusGroup,
+  value: Difficulty | Domain | Skill,
+  label: string,
+  checked: boolean,
+  depth: number,
+  partial = false,
+): FocusRow {
+  return { kind: "option", group, value, label: `${value}  ${label}`, checked, partial, depth };
+}
+
+function toggleDifficultyFocus(focus: Focus, difficulty: Difficulty): Focus {
+  const selected = focus.difficulties.includes(difficulty);
+  if (selected && focus.difficulties.length === 1) {
+    return focus;
+  }
+
+  return {
+    ...focus,
+    difficulties: selected
+      ? focus.difficulties.filter((value) => value !== difficulty)
+      : unique([...focus.difficulties, difficulty]),
+  };
+}
+
+function toggleSkillFocus(focus: Focus, skill: Skill): Focus {
+  const selected = focus.skills.includes(skill);
+  if (selected && focus.skills.length === 1) {
+    return focus;
+  }
+
+  const skills = selected ? focus.skills.filter((value) => value !== skill) : unique([...focus.skills, skill]);
+  return {
+    ...focus,
+    domains: domainsForSkills(skills),
+    skills,
+  };
+}
+
+function toggleDomainFocus(focus: Focus, domain: Domain): Focus {
+  const domainSkills = skillsForDomain(domain);
+  const allSelected = domainSkills.every((skill) => focus.skills.includes(skill));
+
+  if (allSelected) {
+    const remaining = focus.skills.filter((skill) => !domainSkills.includes(skill));
+    if (remaining.length === 0) {
+      return focus;
+    }
+
+    return {
+      ...focus,
+      domains: domainsForSkills(remaining),
+      skills: remaining,
+    };
+  }
+
+  const skills = unique([...focus.skills, ...domainSkills]);
+  return {
+    ...focus,
+    domains: domainsForSkills(skills),
+    skills,
+  };
+}
+
+function normalizeSelection<T extends string>(value: unknown, options: readonly T[], fallback: readonly T[]): T[] {
+  if (!Array.isArray(value)) {
+    return [...fallback];
+  }
+
+  const selected = options.filter((option) => value.includes(option));
+  return selected.length > 0 ? selected : [...fallback];
+}
+
+function normalizeSkills(value: unknown, domains: unknown): Skill[] {
+  if (Array.isArray(value)) {
+    const selected = skillOptions.filter((option) => value.includes(option));
+    if (selected.length > 0) {
+      return selected;
+    }
+  }
+
+  if (Array.isArray(domains)) {
+    const selectedDomains = domainOptions.filter((option) => domains.includes(option));
+    const selectedSkills = selectedDomains.flatMap((domain) => [...skillsForDomain(domain)]);
+    if (selectedSkills.length > 0) {
+      return selectedSkills;
+    }
+  }
+
+  return [...defaultFocus.skills];
+}
+
+function unique<T>(values: T[]): T[] {
+  return values.filter((value, index, list) => list.indexOf(value) === index);
+}
+
+export const difficultyLabels: Record<Difficulty, string> = {
+  E: "Easy",
+  M: "Medium",
+  H: "Hard",
+};
+
+export const domainLabels: Record<Domain, string> = {
+  INI: "Information and Ideas",
+  CAS: "Craft and Structure",
+  EOI: "Expression of Ideas",
+  SEC: "Standard English Conventions",
+};
+
+export const skillLabels: Record<Skill, string> = {
+  CID: "Central Ideas and Details",
+  INF: "Inferences",
+  COE: "Command of Evidence",
+  WIC: "Words in Context",
+  TSP: "Text Structure and Purpose",
+  CTC: "Cross-Text Connections",
+  SYN: "Transitions",
+  TRA: "Rhetorical Synthesis",
+  BOU: "Boundaries",
+  FSS: "Form, Structure, and Sense",
+};

package/src/main.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { runTui } from "./tui.ts";
+
+await runTui();