\n {title}\n

\n {items.map((it, i) => (\n \n {i === cursor ? \"▶\" : \"\"}\n {it.label}\n

\n ))}\n

\n \n \n );\n}\n",[307,222,113],"e1cbdd10-5d41-11f1-938a-1607ee4eb77e",["D",1780267296707],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { DEVICE } from \"../device.ts\";\n\n// A 2×2 grid of up to four tappable tiles — the capacitive primitive. The grid\n// shape IS the four-way branching factor. Fewer than four → faint empty slots.\n// Reused for both profile selection and the knowledge map.\nexport type Tile = { key: string | number; title: string; sub?: string; corner?: string };\n\nexport function TileGrid({ tiles, onTap }: { tiles: Tile[]; onTap: (index: number) => void }) {\n const slots: (Tile | null)[] = [0, 1, 2, 3].map((i) => tiles[i] ?? null);\n return (\n

\n {slots.map((tile, i) => (\n tile && onTap(i)}\n className=\"relative flex flex-col items-center justify-center text-center p-2 disabled:opacity-20\"\n style={{\n background: DEVICE.paper,\n color: DEVICE.ink,\n borderRight: i % 2 === 0 ? `1px solid ${DEVICE.ink}` : \"none\",\n borderBottom: i < 2 ? `1px solid ${DEVICE.ink}` : \"none\",\n }}\n >\n {tile && (\n <>\n

{tile.title}

\n {tile.sub &&

{tile.sub}

}\n {tile.corner && (\n

{tile.corner}

\n )}\n \n )}\n \n ))}\n

\n );\n}\n",[307,222,149],"359ffe90-5cc4-11f1-8d9c-1607ee4eb77e",["D",1780213320815],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { DEVICE } from \"../device.ts\";\nimport { ButtonBar } from \"./ButtonBar.tsx\";\n\n// End of the session batch. Grades have been posted in one request; the server\n// will consolidate (boxes, generation, next window) between now and next time —\n// so there's nothing adaptive to show here, by design. Just a tally + exit.\nexport function SessionEnd({\n counts,\n syncing,\n onDone,\n}: {\n counts: { got: number; almost: number; miss: number };\n syncing: boolean;\n onDone: () => void;\n}) {\n const total = counts.got + counts.almost + counts.miss;\n return (\n

\n SESSION DONE\n

{total}

cards reviewed

✓ got it — {counts.got}

~ almost — {counts.almost}

· didn't know — {counts.miss}

\n {syncing ? \"syncing…\" : \"synced\"}\n

\n \n

\n );\n}\n",[307,222,122],"1a721234-5cc4-11f1-ae05-1607ee4eb77e",["D",1780213275215],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { DEVICE } from \"../device.ts\";\n\n// The bezel. Constrains every child to the panel's exact pixel envelope and\n// two inks, so nothing inside can render at a size or colour the device can't.\nexport function Screen({ children }: { children: React.ReactNode }) {\n return (\n

\n \n \n {children}\n

\n \n

\n {DEVICE.screen.w}×{DEVICE.screen.h} · monochrome · {DEVICE.buttons} buttons\n

\n \n );\n}\n",[307,222,80],"e708a4ca-5d41-11f1-b081-1607ee4eb77e",["D",1780267305545],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { DEVICE } from \"../device.ts\";\nimport type { Quadrant } from \"../api.ts\";\nimport { TileGrid, type Tile } from \"./TileGrid.tsx\";\nimport { ButtonBar } from \"./ButtonBar.tsx\";\n\n// The knowledge map at one level. Tap a quadrant: branch → descend, leaf →\n// review. Back (left button) ascends. The path you tap into IS the interest\n// window. Presentational — App owns the path and the data.\nexport function QuadrantMap({\n path,\n quadrants,\n onTap,\n onBack,\n}: {\n path: { id: number; label: string }[];\n quadrants: Quadrant[];\n onTap: (q: Quadrant) => void;\n onBack: () => void;\n}) {\n const crumb = [\"Knowledge\", ...path.map((p) => p.label)].join(\" › \");\n const tiles: Tile[] = quadrants.map((q) => ({\n key: q.id,\n title: q.label,\n sub: q.branch ? undefined : (q.due ? `${q.due} due` : (q.total ? \"✓ done\" : \"—\")),\n corner: q.branch ? \"▦\" : (q.total && q.mastered === q.total ? \"★\" : undefined),\n }));\n return (\n

\n \n {crumb}\n

\n onTap(quadrants[i])} />\n i === 0 && onBack()} />\n \n );\n}\n",[307,222,158],"bc1adcd2-5d47-11f1-9081-1607ee4eb77e",["D",1780269810498],6,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useEffect, useState } from \"https://esm.sh/react@18.2.0\";\n\n// Admin dashboard — a RICH surface (full colour, normal layout, NOT the device\n// bezel). Read-only. Four lenses: domain exploration, mastery, friction, and a\n// generation-review lens. Doubles as the tool for validating generation.\n\ntype Stats = {\n tree: { id: number; parent: number | null; label: string; ord: number; branch: boolean; total: number; mastered: number; reviews: number; misses: number }[];\n boxes: { box: number; n: number }[];\n friction: { id: number; q: string; node: string; box: number; reviews: number; misses: number; almosts: number }[];\n generators: { node: string; op: string; cards: number; levels: number; distinct: number }[];\n recent: { id: number; node: string; op: string; level: number; q: string; a: string }[];\n genLog: { node: string; op: string; result: string; detail: string }[];\n};\ntype TrajRow = { step: number; nodes: number; maxDepth: number; cards: number; mastered: number; subdivided: number };\ntype Node = Stats[\"tree\"][number];\n\nexport function Dashboard() {\n const [token, setToken] = useState(\"dev-token\");\n const [profiles, setProfiles] = useState<{ id: number; label: string }[]>([]);\n const [profile, setProfile] = useState(null);\n const [stats, setStats] = useState(null);\n const [trajectory, setTrajectory] = useState([]);\n const [err, setErr] = useState(null);\n\n async function loadProfiles() {\n try {\n const r = await fetch(\"/api/profiles\", { headers: { Authorization: `Bearer ${token}` } });\n if (!r.ok) throw new Error(`profiles → ${r.status}`);\n const p = (await r.json()).profiles;\n setProfiles(p);\n setProfile((cur) => cur ?? p[0]?.id ?? null);\n setErr(null);\n } catch (e) { setErr(String(e)); }\n }\n\n async function loadStats(pid: number) {\n try {\n const auth = { Authorization: `Bearer ${token}` };\n const r = await fetch(`/api/admin/stats/${pid}`, { headers: auth });\n if (!r.ok) throw new Error(`stats → ${r.status}`);\n setStats(await r.json());\n const t = await fetch(`/api/admin/trajectory/${pid}`, { headers: auth });\n if (t.ok) setTrajectory((await t.json()).trajectory ?? []);\n setErr(null);\n } catch (e) { setErr(String(e)); }\n }\n\n useEffect(() => { loadProfiles(); }, []);\n useEffect(() => { if (profile != null) loadStats(profile); }, [profile]);\n\n const leakIds = (stats?.recent ?? [])\n .filter((c) => c.a.trim().length > 1 && c.q.toLowerCase().includes(c.a.toLowerCase().trim()))\n .map((c) => c.id);\n\n return (\n

primer · admin

\n setToken((e.target as HTMLInputElement).value)} placeholder=\"bearer token\"\n className=\"border rounded px-2 py-1 text-xs w-28\" />\n \n

\n\n {err &&

{err}

}\n\n

\n {profiles.map((p) => (\n \n ))}\n

\n\n {stats && (\n

\n \n \n \n \n \n \n

\n )}\n

\n );\n}\n\nfunction Section({ title, children }: { title: string; children: React.ReactNode }) {\n return (\n

{title}

\n {children}\n

\n );\n}\n\nfunction Bar({ frac, color, width = 128 }: { frac: number; color: string; width?: number }) {\n return (\n

\n );\n}\n\nfunction Exploration({ tree }: { tree: Stats[\"tree\"] }) {\n const tops = tree.filter((n) => n.parent === null);\n const childrenOf = (id: number) => tree.filter((n) => n.parent === id);\n const Row = ({ n, depth }: { n: Node; depth: number }) => {\n const frac = n.total ? n.mastered / n.total : 0;\n return (\n <>\n

\n {n.branch ? \"▦ \" : \"\"}{n.label}\n {n.branch\n ? {childrenOf(n.id).length} areas\n : (\n <>\n \n {n.mastered}/{n.total}\n {n.misses > 0 && {n.misses} miss}\n \n )}\n

\n {n.branch && childrenOf(n.id).map((c) => )}\n \n );\n };\n return (\n

\n {tops.map((n) => )}\n

Depth grows where mastery does — the shape is the explored frontier.

\n );\n}\n\nfunction Mastery({ boxes, tree }: { boxes: Stats[\"boxes\"]; tree: Stats[\"tree\"] }) {\n const byBox = new Map(boxes.map((b) => [b.box, b.n]));\n const max = Math.max(1, ...boxes.map((b) => b.n));\n const leaves = tree.filter((n) => !n.branch);\n const total = leaves.reduce((s, n) => s + n.total, 0);\n const mastered = leaves.reduce((s, n) => s + n.mastered, 0);\n return (\n

{mastered} / {total} cards mastered ({total ? Math.round((mastered / total) * 100) : 0}%)

\n {[1, 2, 3, 4, 5].map((b) => {\n const n = byBox.get(b) ?? 0;\n return (\n

{n}

= 3 ? \"#16a34a\" : \"#94a3b8\", minHeight: 2 }} />\n

box {b}

\n );\n })}\n

Boxes 3+ count as mastered. New cards aren't boxed yet.

\n );\n}\n\nfunction Friction({ rows }: { rows: Stats[\"friction\"] }) {\n return (\n

\n {rows.length === 0\n ?

No friction yet — nothing missed or stuck.

\n : (\n \n \n \n \n \n \n \n {rows.map((r) => (\n \n \n \n \n \n \n \n ))}\n \n

Card	Node	Box	Reviews	Miss
{r.q}	{r.node}	{r.box}	{r.reviews}	{r.misses}

\n )}\n

Missed often, or reviewed 3+ times and still in box 1–2.

\n );\n}\n\nfunction Generation({ generators, recent, leakIds }: { generators: Stats[\"generators\"]; recent: Stats[\"recent\"]; leakIds: number[] }) {\n return (\n

\n {generators.length === 0\n ?

No generators authored yet — run a generation tick to populate this.

\n : (\n

Cards per generator function — short bars mean the family didn't earn the machinery.

\n {generators.map((g, i) => (\n

\n {g.node} · {g.op}\n \n {g.cards} cards · {g.levels} level{g.levels === 1 ? \"\" : \"s\"}\n {g.distinct < g.cards && {g.cards - g.distinct} dup}\n

\n ))}\n

\n )}\n

Newest cards — eyeball for leakage / level drift:

\n {recent.map((c) => (\n

\n {c.node}·L{c.level}\n {c.q}\n → {c.a}\n {leakIds.includes(c.id) && leak?}\n

\n ))}\n

\n );\n}\n\nfunction Trajectory({ data }: { data: TrajRow[] }) {\n if (!data.length) {\n return (\n

No simulation steps yet — run the speed-run to populate.

\n );\n }\n const W = 520, H = 150, pad = 22;\n const steps = data.map((d) => d.step);\n const minX = Math.min(...steps), maxX = Math.max(...steps);\n const maxY = Math.max(1, ...data.map((d) => Math.max(d.cards, d.nodes, d.mastered)));\n const px = (s: number) => pad + (maxX === minX ? 0 : (s - minX) / (maxX - minX)) * (W - 2 * pad);\n const py = (v: number) => H - pad - (v / maxY) * (H - 2 * pad);\n const path = (pick: (d: TrajRow) => number) =>\n data.map((d, i) => `${i === 0 ? \"M\" : \"L\"}${px(d.step).toFixed(1)},${py(pick(d)).toFixed(1)}`).join(\" \");\n const series: [string, string, (d: TrajRow) => number][] = [\n [\"cards\", \"#6366f1\", (d) => d.cards],\n [\"mastered\", \"#16a34a\", (d) => d.mastered],\n [\"nodes\", \"#94a3b8\", (d) => d.nodes],\n ];\n return (\n

\n \n

\n ● cards\n ● mastered\n ● nodes\n ┆ subdivision\n {data.length} steps · max depth {Math.max(...data.map((d) => d.maxDepth))}\n

\n );\n}\n\nfunction GenLog({ rows }: { rows: Stats[\"genLog\"] }) {\n const color = (r: string) => (r === \"made\" ? \"text-green-600\" : r === \"error\" ? \"text-red-600\" : \"text-gray-400\");\n return (\n

\n {rows.length === 0\n ?

No generation runs logged yet.

\n : (\n

\n {rows.map((r, i) => (\n

\n {r.result}\n {r.node} · {r.op}\n {r.detail}\n

\n ))}\n

\n )}\n

Every attempt — made, skipped, or rejected. No more silent no-ops.

\n );\n}\n",[307,222,176],"7fd0ca3c-5cd1-11f1-ac52-1607ee4eb77e",["D",1780219028733],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useEffect, useState } from \"https://esm.sh/react@18.2.0\";\nimport { DEVICE, GRADES } from \"../device.ts\";\nimport type { Card } from \"../api.ts\";\nimport { ButtonBar } from \"./ButtonBar.tsx\";\n\n// The procedural UI interpreter — the firmware's job, in the sim.\n// Input: a card's `op` tag + pre-rendered q/a strings. The device owns a fixed\n// layout per operation (the low-n op set IS the layout vocabulary); the server\n// sends no layout. Add a new op → add a case here and reflash. That coupling is\n// the deliberate \"lean\" choice from the spec.\n\nconst OP_TAG: Record = {\n \"name\": \"RECALL\",\n \"recall-instance\": \"RECALL\",\n \"compose\": \"SAY\",\n};\n\nexport function CardView({\n card,\n index,\n total,\n onGrade,\n}: {\n card: Card;\n index: number;\n total: number;\n onGrade: (grade: string) => void;\n}) {\n const [revealed, setRevealed] = useState(false);\n const [flashing, setFlashing] = useState(false);\n\n // Reset to the front whenever a new card arrives. Models a full refresh.\n useEffect(() => {\n setRevealed(false);\n setFlashing(true);\n const t = setTimeout(() => setFlashing(false), DEVICE.refresh.full);\n return () => clearTimeout(t);\n }, [card.id]);\n\n const tag = OP_TAG[card.op] ?? card.op.toUpperCase();\n\n function reveal() {\n if (revealed || flashing) return;\n setFlashing(true); // partial refresh of the reveal region\n setRevealed(true);\n setTimeout(() => setFlashing(false), DEVICE.refresh.partial);\n }\n\n // Pre-commit: question first, answer only after a deliberate reveal.\n // Tapping the card is the primary reveal (capacitive panel); the centre\n // button is the secondary affordance / hint to the same single action.\n function handleButton(i: number) {\n if (!revealed) {\n if (i === 1) reveal();\n return;\n }\n onGrade(GRADES[i].key);\n }\n\n return (\n

\n {/* Tappable face — primary reveal affordance */}\n \n

\n {tag}\n {index + 1} / {total}\n

\n\n

{card.q}

\n\n

\n {revealed\n ? (\n <>\n

ANSWER

{card.a}

\n \n )\n :

tap to reveal

}\n

\n\n {/* Buttons: REVEAL (centre, secondary) before; grade triad after */}\n {revealed\n ? g.label)} onPress={handleButton} disabled={flashing} />\n : }\n

\n );\n}\n",[307,222,104],"1fa23432-5cc4-11f1-8c4d-1607ee4eb77e",["D",1780213283917],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { DEVICE } from \"../device.ts\";\n\n// The three physical buttons along the bottom edge. This is the ENTIRE input\n// surface — every screen must express its choices as ≤3 of these. Pass exactly\n// DEVICE.buttons labels; a null label is a dead (unlabelled) key on that screen.\nexport function ButtonBar({\n labels,\n onPress,\n disabled,\n}: {\n labels: (string | null)[];\n onPress: (index: number) => void;\n disabled?: boolean;\n}) {\n const slots = Array.from({ length: DEVICE.buttons }, (_, i) => labels[i] ?? null);\n return (\n \n {slots.map((label, i) => (\n onPress(i)}\n className=\"py-3 text-[13px] font-bold uppercase tracking-wide disabled:opacity-25\"\n style={{\n background: DEVICE.paper,\n color: DEVICE.ink,\n borderLeft: i === 0 ? \"none\" : `1px solid ${DEVICE.ink}`,\n }}\n >\n {label ?? \"·\"}\n \n ))}\n \n );\n}\n",[307,222,95],"f928a718-5d41-11f1-8efa-1607ee4eb77e",["D",1780267335950],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useEffect, useState } from \"https://esm.sh/react@18.2.0\";\nimport {\n type Card,\n fetchProfiles,\n fetchQuadrants,\n fetchSession,\n postGrades,\n type Profile,\n type Quadrant,\n} from \"../api.ts\";\nimport type { GradeKey } from \"../device.ts\";\nimport { Screen } from \"./Screen.tsx\";\nimport { TileGrid, type Tile } from \"./TileGrid.tsx\";\nimport { QuadrantMap } from \"./QuadrantMap.tsx\";\nimport { CardView } from \"./CardView.tsx\";\nimport { SessionEnd } from \"./SessionEnd.tsx\";\n\n// The device session state machine. Profile → navigate the quadrant map →\n// tap a leaf → review one batch (graded offline) → post once → back to the\n// level you left. Only what the firmware will do.\n\ntype Phase = \"loading\" | \"profile\" | \"map\" | \"review\" | \"empty\" | \"end\";\ntype Crumb = { id: number; label: string };\n\nexport function App() {\n const [phase, setPhase] = useState(\"loading\");\n const [profiles, setProfiles] = useState([]);\n const [profile, setProfile] = useState(null);\n\n const [path, setPath] = useState([]); // branches descended into (not the leaf)\n const [quadrants, setQuadrants] = useState([]);\n\n const [cards, setCards] = useState([]);\n const [pos, setPos] = useState(0);\n const [buffer, setBuffer] = useState<{ id: number; grade: GradeKey }[]>([]);\n const [syncing, setSyncing] = useState(false);\n\n useEffect(() => {\n fetchProfiles().then((p) => { setProfiles(p); setPhase(\"profile\"); }).catch(() => setPhase(\"empty\"));\n }, []);\n\n function loadLevel(pid: number, p: Crumb[]) {\n const parent = p.length ? p[p.length - 1].id : \"root\";\n fetchQuadrants(pid, parent).then((q) => { setQuadrants(q); setPath(p); setPhase(\"map\"); });\n }\n\n function pickProfile(i: number) {\n const p = profiles[i];\n setProfile(p);\n loadLevel(p.id, []);\n }\n\n function tapQuadrant(q: Quadrant) {\n if (!profile) return;\n if (q.branch) {\n loadLevel(profile.id, [...path, { id: q.id, label: q.label }]);\n } else {\n fetchSession(profile.id, q.id).then((batch) => {\n setCards(batch);\n setPos(0);\n setBuffer([]);\n setPhase(batch.length ? \"review\" : \"empty\");\n });\n }\n }\n\n function back() {\n if (profile && path.length) loadLevel(profile.id, path.slice(0, -1));\n }\n\n function grade(g: string) {\n const next = [...buffer, { id: cards[pos].id, grade: g as GradeKey }];\n setBuffer(next);\n if (pos + 1 < cards.length) {\n setPos(pos + 1);\n } else {\n setSyncing(true);\n setPhase(\"end\");\n postGrades(profile!.id, next).finally(() => setSyncing(false));\n }\n }\n\n // Return to the level we were on; counts refresh from the server.\n function afterSession() {\n if (profile) loadLevel(profile.id, path);\n else setPhase(\"profile\");\n }\n\n const counts = {\n got: buffer.filter((b) => b.grade === \"got\").length,\n almost: buffer.filter((b) => b.grade === \"almost\").length,\n miss: buffer.filter((b) => b.grade === \"miss\").length,\n };\n\n const profileTiles: Tile[] = profiles.map((p) => ({ key: p.id, title: p.label }));\n\n return (\n

P R I M E R

\n \n {phase === \"loading\" && …}\n {phase === \"profile\" && (\n

\n WHO'S PLAYING?\n

\n \n

\n )}\n {phase === \"map\" && (\n \n )}\n {phase === \"review\" && cards[pos] && (\n \n )}\n {phase === \"empty\" && (\n \n )}\n {phase === \"end\" && }\n \n view source\n

\n );\n}\n\nfunction Centered({ children }: { children: React.ReactNode }) {\n return

{children}

;\n}\n",[307,222,131],"pulls","branches","forks","envVars",{"_361":241,"_363":26},"connections",{"_361":26,"_362":26},"count","unfilledCount","emptyCount",{"_49":552,"_13":307,"_78":300,"_59":-5,"_51":52,"_301":339,"_302":24,"_53":553,"_55":26,"_81":223,"_304":-5,"_83":30,"_305":-5,"_397":554,"_17":555},{"_49":299,"_13":222,"_78":221,"_59":300,"_51":52,"_301":56,"_302":24,"_53":549,"_55":26,"_81":223,"_304":-5,"_83":30,"_305":-5,"_397":550,"_17":551},{"_49":350,"_13":131,"_78":130,"_59":221,"_51":52,"_301":161,"_302":24,"_53":546,"_55":241,"_81":82,"_304":352,"_83":30,"_305":-5,"_397":547,"_17":548},{"_49":346,"_13":95,"_78":94,"_59":221,"_51":52,"_301":89,"_302":24,"_53":543,"_55":26,"_81":82,"_304":348,"_83":30,"_305":-5,"_397":544,"_17":545},{"_49":342,"_13":104,"_78":103,"_59":221,"_51":52,"_301":134,"_302":24,"_53":540,"_55":241,"_81":82,"_304":344,"_83":30,"_305":-5,"_397":541,"_17":542},{"_49":337,"_13":176,"_78":175,"_59":221,"_51":52,"_301":216,"_302":24,"_53":537,"_55":339,"_81":82,"_304":340,"_83":30,"_305":-5,"_397":538,"_17":539},{"_49":333,"_13":158,"_78":157,"_59":221,"_51":52,"_301":152,"_302":24,"_53":534,"_55":26,"_81":82,"_304":335,"_83":30,"_305":-5,"_397":535,"_17":536},{"_49":329,"_13":80,"_78":79,"_59":221,"_51":52,"_301":56,"_302":24,"_53":531,"_55":26,"_81":82,"_304":331,"_83":30,"_305":-5,"_397":532,"_17":533},{"_49":325,"_13":122,"_78":121,"_59":221,"_51":52,"_301":116,"_302":24,"_53":528,"_55":26,"_81":82,"_304":327,"_83":30,"_305":-5,"_397":529,"_17":530},{"_49":321,"_13":149,"_78":148,"_59":221,"_51":52,"_301":142,"_302":24,"_53":525,"_55":26,"_81":82,"_304":323,"_83":30,"_305":-5,"_397":526,"_17":527},{"_49":317,"_13":113,"_78":112,"_59":221,"_51":52,"_301":107,"_302":24,"_53":522,"_55":26,"_81":82,"_304":319,"_83":30,"_305":-5,"_397":523,"_17":524},{"_49":514,"_13":515,"_78":516,"_59":300,"_51":52,"_301":517,"_302":24,"_53":518,"_55":26,"_81":21,"_304":519,"_83":30,"_305":-5,"_397":520,"_17":521},{"_49":506,"_13":507,"_78":508,"_59":300,"_51":52,"_301":509,"_302":24,"_53":510,"_55":26,"_81":82,"_304":511,"_83":30,"_305":-5,"_397":512,"_17":513},{"_49":498,"_13":499,"_78":500,"_59":300,"_51":52,"_301":501,"_302":24,"_53":502,"_55":241,"_81":82,"_304":503,"_83":30,"_305":-5,"_397":504,"_17":505},{"_49":490,"_13":491,"_78":492,"_59":300,"_51":52,"_301":493,"_302":24,"_53":494,"_55":241,"_81":82,"_304":495,"_83":30,"_305":-5,"_397":496,"_17":497},{"_49":482,"_13":483,"_78":484,"_59":300,"_51":52,"_301":485,"_302":24,"_53":486,"_55":26,"_81":21,"_304":487,"_83":30,"_305":-5,"_397":488,"_17":489},{"_49":474,"_13":475,"_78":476,"_59":300,"_51":52,"_301":477,"_302":24,"_53":478,"_55":26,"_81":82,"_304":479,"_83":30,"_305":-5,"_397":480,"_17":481},{"_49":467,"_13":468,"_78":469,"_59":-5,"_51":52,"_301":264,"_302":24,"_53":470,"_55":241,"_81":21,"_304":471,"_83":30,"_305":-5,"_397":472,"_17":473},{"_49":458,"_13":459,"_78":460,"_59":-5,"_51":52,"_301":461,"_302":24,"_53":462,"_55":463,"_81":21,"_304":464,"_83":30,"_305":-5,"_397":465,"_17":466},{"_49":449,"_13":450,"_78":451,"_59":-5,"_51":52,"_301":452,"_302":24,"_53":453,"_55":26,"_81":454,"_304":455,"_83":30,"_305":-5,"_397":456,"_17":457},{"_49":441,"_13":442,"_78":443,"_59":-5,"_51":52,"_301":444,"_302":24,"_53":445,"_55":134,"_81":82,"_304":446,"_83":30,"_305":-5,"_397":447,"_17":448},{"_49":433,"_13":434,"_78":435,"_59":-5,"_51":52,"_301":436,"_302":24,"_53":437,"_55":116,"_81":82,"_304":438,"_83":30,"_305":-5,"_397":439,"_17":440},{"_49":425,"_13":426,"_78":236,"_59":-5,"_51":52,"_301":427,"_302":24,"_53":428,"_55":125,"_81":429,"_304":430,"_83":30,"_305":-5,"_397":431,"_17":432},{"_49":417,"_13":418,"_78":419,"_59":-5,"_51":52,"_301":420,"_302":24,"_53":421,"_55":26,"_81":82,"_304":422,"_83":30,"_305":-5,"_397":423,"_17":424},{"_49":409,"_13":410,"_78":411,"_59":-5,"_51":52,"_301":412,"_302":24,"_53":413,"_55":241,"_81":82,"_304":414,"_83":30,"_305":-5,"_397":415,"_17":416},{"_49":400,"_13":401,"_78":402,"_59":-5,"_51":52,"_301":403,"_302":24,"_53":404,"_55":405,"_81":82,"_304":406,"_83":30,"_305":-5,"_397":407,"_17":408},{"_49":391,"_13":392,"_78":393,"_59":-5,"_51":52,"_301":394,"_302":24,"_53":395,"_55":26,"_81":82,"_304":396,"_83":30,"_305":-5,"_397":398,"_17":399},"ba83eb14-5cd1-11f1-8414-1607ee4eb77e","test_gen.ts","ba83ebe6-5cd1-11f1-8414-1607ee4eb77e",25,["D",1780219127217],"import { runGenerator, safeBody } from \"./gen.ts\";\n\n// Verifies the materialisation seam end-to-end WITHOUT any API key: hand-written\n// generator bodies (exactly what the LLM is asked to emit) applied to params.\n// Run with: run_file. Proves the executor + guards + arithmetic-correct-by-code.\n\nconst addBody = \"return { q: `${p.x} + ${p.y} = ?`, a: String(p.x + p.y) };\";\nconst spellBody = \"return { q: `Spell: ${p.word}`, a: p.word.split('').join(' - ') };\";\nconst oppBody = \"return { q: `Opposite of ${p.word}?`, a: p.opposite };\";\nconst evilBody = \"return fetch('http://evil').then(() => ({ q: 'x', a: 'y' }));\";\nconst loopBody = \"while (true) {} return { q: 'x', a: 'y' };\";\n\nconsole.log(\"guard add :\", safeBody(addBody)); // true\nconsole.log(\"guard spell:\", safeBody(spellBody)); // true\nconsole.log(\"guard opp :\", safeBody(oppBody)); // true\nconsole.log(\"guard evil :\", safeBody(evilBody)); // false (fetch)\nconsole.log(\"guard loop :\", safeBody(loopBody)); // false (while(true))\nconsole.log(\"add 7,8 :\", JSON.stringify(runGenerator(addBody, { x: 7, y: 8 })));\nconsole.log(\"add 13,9 :\", JSON.stringify(runGenerator(addBody, { x: 13, y: 9 })));\nconsole.log(\"spell :\", JSON.stringify(runGenerator(spellBody, { word: \"friend\" })));\nconsole.log(\"opposite :\", JSON.stringify(runGenerator(oppBody, { word: \"big\", opposite: \"small\" })));\n\nexport default () => \"ok\";\n","children",[],[392],"544b1950-5d47-11f1-8f18-1607ee4eb77e","stats.ts","29bdf27e-5d43-11f1-9f3a-1607ee4eb77e",78,["D",1780269636332],4,"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\n// Read-only observability for the admin dashboard: mastery, domain exploration,\n// friction, and a generation-review lens. Per profile (except generation, which\n// is over the shared card pool).\n\nconst MASTERY_BOX = 3;\nconst num = (v: unknown) => Number(v ?? 0);\n\nexport async function getStats(profileId: number) {\n // Tree with per-node aggregates — mastery + friction inputs for the map.\n const tree = await sqlite.execute({\n sql: `\n SELECT n.id, n.parent, n.label, n.ord,\n (SELECT COUNT(*) FROM nodes k WHERE k.parent = n.id) AS kids,\n (SELECT COUNT(*) FROM cards x WHERE x.node_id = n.id AND x.superseded_by IS NULL) AS total,\n (SELECT COUNT(*) FROM cards x JOIN box_state b ON b.card_id = x.id\n WHERE x.node_id = n.id AND b.profile_id = ? AND b.box >= ${MASTERY_BOX}) AS mastered,\n (SELECT COUNT(*) FROM reviews rv JOIN cards x ON x.id = rv.card_id\n WHERE x.node_id = n.id AND rv.profile_id = ?) AS reviews,\n (SELECT COUNT(*) FROM reviews rv JOIN cards x ON x.id = rv.card_id\n WHERE x.node_id = n.id AND rv.profile_id = ? AND rv.grade = 'miss') AS misses\n FROM nodes n ORDER BY (n.parent IS NOT NULL), n.parent, n.ord\n `,\n args: [profileId, profileId, profileId],\n });\n\n // Leitner box distribution for this profile.\n const boxes = await sqlite.execute({\n sql: `SELECT box, COUNT(*) AS n FROM box_state WHERE profile_id = ? GROUP BY box ORDER BY box`,\n args: [profileId],\n });\n\n // Friction: cards missed, or stuck (reviewed a lot, still low box).\n const friction = await sqlite.execute({\n sql: `\n SELECT c.id, c.q, n.label AS node, COALESCE(bs.box, 1) AS box,\n COUNT(rv.id) AS reviews,\n SUM(CASE WHEN rv.grade = 'miss' THEN 1 ELSE 0 END) AS misses,\n SUM(CASE WHEN rv.grade = 'almost' THEN 1 ELSE 0 END) AS almosts\n FROM cards c\n JOIN nodes n ON n.id = c.node_id\n JOIN reviews rv ON rv.card_id = c.id AND rv.profile_id = ?\n LEFT JOIN box_state bs ON bs.card_id = c.id AND bs.profile_id = ?\n WHERE c.superseded_by IS NULL\n GROUP BY c.id\n HAVING misses > 0 OR (reviews >= 3 AND box <= 2)\n ORDER BY misses DESC, box ASC, reviews DESC\n LIMIT 20\n `,\n args: [profileId, profileId],\n });\n\n // Generation review, derived from CARDS not generators — generators are\n // transient (deleted on subdivision), but the cards they emit persist. Each\n // generated family (operands look like JSON params) with its yield, level\n // spread, and distinct-content count (cards > distinct ⇒ residual duplicates).\n const generators = await sqlite.execute(`\n SELECT n.label AS node, c.op,\n COUNT(*) AS cards,\n COUNT(DISTINCT c.level) AS levels,\n COUNT(DISTINCT COALESCE(c.content_hash, c.q || c.a)) AS distinct_content\n FROM cards c JOIN nodes n ON n.id = c.node_id\n WHERE c.superseded_by IS NULL AND c.operands LIKE '{%'\n GROUP BY c.node_id, c.op\n ORDER BY cards DESC\n `);\n\n // Newest cards, to eyeball quality / leakage / drift directly.\n const recent = await sqlite.execute(`\n SELECT c.id, n.label AS node, c.op, c.level, c.q, c.a\n FROM cards c JOIN nodes n ON n.id = c.node_id\n WHERE c.superseded_by IS NULL\n ORDER BY c.id DESC LIMIT 15\n `);\n\n // Generation log — every attempt's outcome, so failures are visible.\n const genlog = await sqlite.execute(`\n SELECT COALESCE(n.label, '(removed)') AS node, g.op, g.result, g.detail\n FROM gen_log g LEFT JOIN nodes n ON n.id = g.node_id\n ORDER BY g.id DESC LIMIT 15\n `);\n\n return {\n tree: tree.rows.map((r) => ({\n id: num(r.id),\n parent: r.parent === null ? null : num(r.parent),\n label: String(r.label),\n ord: num(r.ord),\n branch: num(r.kids) > 0,\n total: num(r.total),\n mastered: num(r.mastered),\n reviews: num(r.reviews),\n misses: num(r.misses),\n })),\n boxes: boxes.rows.map((r) => ({ box: num(r.box), n: num(r.n) })),\n friction: friction.rows.map((r) => ({\n id: num(r.id),\n q: String(r.q),\n node: String(r.node),\n box: num(r.box),\n reviews: num(r.reviews),\n misses: num(r.misses),\n almosts: num(r.almosts),\n })),\n generators: generators.rows.map((r) => ({\n node: String(r.node),\n op: String(r.op),\n cards: num(r.cards),\n levels: num(r.levels),\n distinct: num(r.distinct_content),\n })),\n recent: recent.rows.map((r) => ({\n id: num(r.id),\n node: String(r.node),\n op: String(r.op),\n level: num(r.level),\n q: String(r.q),\n a: String(r.a),\n })),\n genLog: genlog.rows.map((r) => ({\n node: String(r.node),\n op: String(r.op ?? \"\"),\n result: String(r.result),\n detail: String(r.detail ?? \"\"),\n })),\n };\n}\n",[],[401],"2ae04348-5d46-11f1-829e-1607ee4eb77e","sim.ts","2d7d4dcc-5d45-11f1-8fa3-1607ee4eb77e",67,["D",1780269136972],"import {\n applyGrades,\n cardsOfNode,\n type Grade,\n getTrajectory,\n lastStep,\n nodeCardStats,\n recordTrajectory,\n resetTrajectory,\n simNodes,\n simReviewSet,\n} from \"./db.ts\";\nimport { subdivide, tickGenerate } from \"./gen.ts\";\n\n// Speed-run: compress sessions of use + generation + structural growth into\n// steps. RESUMABLE — one step per call, each persisting a trajectory snapshot,\n// so a long compressed history is many quick calls (each well under the request\n// timeout) and the growth curve survives to be charted. Real Leitner SPACING is\n// compressed away; box transitions still follow the real rules.\n\nconst SUBDIVIDE_AT = 5; // a mastered leaf with >= this many cards refines into four\nconst MAX_DEPTH = 3; // don't subdivide past this depth\nconst GROW_CAP = 2; // nodes card-grown per step (keeps one step inside the budget)\nconst SUBDIVIDE_CAP = 1; // subdivisions per step\nconst REVIEW_CAP = 40; // cards the learner practises per step\n\n// Simple learner: P(correct) rises with the card's box (a proxy for exposure,\n// so steps are stateless / resumable); some slip to almost / miss.\nfunction gradeFor(box: number): Grade {\n const p = Math.min(0.6 + 0.2 * box, 0.95);\n const r = Math.random();\n if (r < p) return \"got\";\n if (r < p + 0.18) return \"almost\";\n return \"miss\";\n}\n\nfunction depthOf(id: number, parentOf: Map): number {\n let d = 0;\n let cur: number | null = id;\n while (cur != null && parentOf.get(cur) != null) {\n cur = parentOf.get(cur)!;\n d++;\n if (d > 20) break;\n }\n return d;\n}\n\nasync function snapshot(profileId: number, step: number, subdivided: number) {\n const nodes = await simNodes();\n const parentOf = new Map(nodes.map((n) => [n.id, n.parent]));\n const stats = await nodeCardStats(profileId);\n return {\n step,\n nodes: nodes.length,\n maxDepth: Math.max(0, ...nodes.map((n) => depthOf(n.id, parentOf))),\n cards: stats.reduce((a, s) => a + s.cards, 0),\n mastered: stats.reduce((a, s) => a + s.mastered, 0),\n subdivided,\n };\n}\n\n// Run exactly one step and persist its snapshot. Resumable: step number and the\n// learner's \"exposure\" both come from persisted state, so the next call resumes.\nexport async function simStep(profileId: number) {\n const step = (await lastStep(profileId)) + 1;\n\n // 1. Learner practises unmastered cards (box is the exposure proxy).\n const set = await simReviewSet(profileId, REVIEW_CAP);\n if (set.length) {\n const grades = set.map((c) => ({ id: c.id, grade: gradeFor(c.box ?? 0) }));\n await applyGrades(profileId, grades);\n }\n\n // 2. Refine saturated mastered leaves (structure grows — depth).\n const nodes = await simNodes();\n const parentOf = new Map(nodes.map((n) => [n.id, n.parent]));\n const hasKids = new Set(nodes.map((n) => n.parent).filter((p): p is number => p != null));\n const stats = new Map((await nodeCardStats(profileId)).map((s) => [s.id, s]));\n let subdivided = 0;\n for (const n of nodes) {\n if (subdivided >= SUBDIVIDE_CAP) break;\n if (hasKids.has(n.id)) continue;\n const s = stats.get(n.id);\n if (!s || s.cards < SUBDIVIDE_AT || s.mastered < s.cards) continue;\n if (depthOf(n.id, parentOf) >= MAX_DEPTH) continue;\n const res = await subdivide({ id: n.id, label: n.label }, await cardsOfNode(n.id));\n if (res) subdivided++;\n }\n\n // 3. Grow cards on mastered leaves under the cap (ladder within resolution).\n await tickGenerate({ perNode: 4, cap: GROW_CAP });\n\n const snap = await snapshot(profileId, step, subdivided);\n await recordTrajectory(profileId, snap);\n return snap;\n}\n\n// Convenience loop (still subject to the request timeout for large n — prefer\n// repeated simStep calls for long histories).\nexport async function simulate(profileId: number, steps: number) {\n for (let i = 0; i < steps; i++) await simStep(profileId);\n return { profile: profileId, trajectory: await getTrajectory(profileId) };\n}\n\nexport { getTrajectory, resetTrajectory };\n",[],[410],"84d9aa12-5cd1-11f1-8371-1607ee4eb77e","llm.ts","84d9aae4-5cd1-11f1-8371-1607ee4eb77e",18,["D",1780219037184],"import OpenAI from \"npm:openai\";\n\n// BYO-key OpenAI access for the generation crons. The key is a Val Town secret\n// (OPENAI_API_KEY) — server-side, per the key-locus decision for this private\n// family substrate. Absent key → hasKey() is false and generation no-ops cleanly.\n\nconst KEY = Deno.env.get(\"OPENAI_API_KEY\");\nconst MODEL = Deno.env.get(\"PRIMER_MODEL\") ?? \"gpt-4o-mini\";\n\nexport const hasKey = () => !!KEY;\n\n// Ask for a JSON object and parse it. Returns null on absent key or parse failure\n// so callers can degrade gracefully rather than throw inside a cron.\nexport async function completeJSON(system: string, user: string): Promise {\n if (!KEY) return null;\n const client = new OpenAI({ apiKey: KEY });\n const r = await client.chat.completions.create({\n model: MODEL,\n temperature: 0.5,\n response_format: { type: \"json_object\" },\n messages: [\n { role: \"system\", content: system },\n { role: \"user\", content: user },\n ],\n });\n const text = r.choices[0]?.message?.content ?? \"\";\n try {\n return JSON.parse(text) as T;\n } catch {\n const m = text.match(/\\{[\\s\\S]*\\}/);\n return m ? (JSON.parse(m[0]) as T) : null;\n }\n}\n",[],[418],"3527330c-5d46-11f1-a015-1607ee4eb77e","index.ts",70,["D",1780269154590],"http","import { parseVal, serveFile } from \"https://esm.town/v/std/utils/index.ts\";\nimport { Hono } from \"npm:hono\";\nimport { applyGrades, getBranches, getChildren, getProfiles, getSessionBatch, init } from \"./db.ts\";\nimport { tickGenerate } from \"./gen.ts\";\nimport { getStats } from \"./stats.ts\";\nimport { simulate, simStep, getTrajectory, resetTrajectory } from \"./sim.ts\";\n\n// Device-scoped bearer token. Provisioned out-of-band (firmware / Val Town secret),\n// never typed into the constrained UI. Defaults to \"dev-token\" so the prototype\n// runs immediately; set PRIMER_DEVICE_TOKEN to lock it down for real.\nconst TOKEN = Deno.env.get(\"PRIMER_DEVICE_TOKEN\") ?? \"dev-token\";\n\nconst app = new Hono();\n\n// --- Frontend (open; it's only the simulator chrome + JS, no data) ---\napp.get(\"/\", () => serveFile(\"/frontend/index.html\"));\napp.get(\"/admin\", () => serveFile(\"/frontend/admin.html\"));\napp.get(\"/frontend/**/*\", (c) => serveFile(c.req.path));\napp.get(\"/source\", (c) => c.redirect(parseVal().links.self.val));\n\n// --- API (bearer-gated, device-scoped; profile named per request) ---\napp.use(\"/api/*\", async (c, next) => {\n if (c.req.header(\"Authorization\") !== `Bearer ${TOKEN}`) {\n return c.json({ error: \"unauthorized\" }, 401);\n }\n await init();\n await next();\n});\n\napp.get(\"/api/profiles\", async (c) => c.json({ profiles: await getProfiles() }));\napp.get(\"/api/branches\", async (c) => c.json({ branches: await getBranches() }));\napp.get(\"/api/quadrants/:profile/:parent\", async (c) => {\n const parent = c.req.param(\"parent\");\n return c.json({\n quadrants: await getChildren(\n Number(c.req.param(\"profile\")),\n parent === \"root\" ? null : Number(parent),\n ),\n });\n});\napp.get(\"/api/session/:profile/:branch\", async (c) =>\n c.json({\n cards: await getSessionBatch(\n Number(c.req.param(\"profile\")),\n Number(c.req.param(\"branch\")),\n ),\n }));\napp.post(\"/api/grades\", async (c) => {\n const body = await c.req.json();\n const applied = await applyGrades(Number(body.profile), body.grades ?? []);\n return c.json({ ok: true, applied });\n});\n\n// Admin: run a generation tick on demand. ?force= bypasses the mastery\n// gate so a node can be grown for testing without first mastering its cards.\napp.post(\"/api/admin/generate\", async (c) => {\n return c.json(await tickGenerate({}));\n});\napp.post(\"/api/admin/generate/:force\", async (c) => {\n const force = Number(c.req.param(\"force\")) || undefined;\n return c.json(await tickGenerate({ force }));\n});\napp.get(\"/api/admin/stats/:profile\", async (c) => c.json(await getStats(Number(c.req.param(\"profile\")))));\napp.post(\"/api/admin/simulate/:profile/:steps\", async (c) => {\n const steps = Math.min(20, Math.max(1, Number(c.req.param(\"steps\")) || 8));\n return c.json(await simulate(Number(c.req.param(\"profile\")), steps));\n});\napp.post(\"/api/admin/sim-step/:profile\", async (c) => c.json(await simStep(Number(c.req.param(\"profile\")))));\napp.get(\"/api/admin/trajectory/:profile\", async (c) => c.json({ trajectory: await getTrajectory(Number(c.req.param(\"profile\"))) }));\napp.post(\"/api/admin/sim-reset/:profile\", async (c) => {\n await resetTrajectory(Number(c.req.param(\"profile\")));\n return c.json({ ok: true });\n});\n\n// Surface real stack traces instead of \"Internal Server Error\".\napp.onError((err) => Promise.reject(err));\n\nexport default app.fetch;\n",[],[426],"4ca22342-5d47-11f1-94c7-1607ee4eb77e","gen.ts","ab7c4652-5cd1-11f1-a34b-1607ee4eb77e",76,["D",1780269623479],"import {\n cardsOfNode,\n existingParams,\n existingQuestions,\n type Generator,\n getGenerator,\n insertCard,\n nodesReadyToGrow,\n recordGenLog,\n saveGenerator,\n subdivideNode,\n} from \"./db.ts\";\nimport { completeJSON, hasKey } from \"./llm.ts\";\n\n// Generation = curriculum (decide WHAT to teach) + materialisation (turn that\n// into cards). The two stay separate so the materialisation strategy is\n// swappable — see the SEAM below.\n\nconst canon = (p: unknown) => JSON.stringify(p);\n\n// Only retrieval ops are text-honest (the answer is withheld from the prompt).\n// Production ops (spelling, say/compose) need the audio path; the curriculum\n// cannot author them until audio exists. Gate by required modality.\nconst TEXT_OPS = new Set([\"name\", \"recall-instance\"]);\n\n// ============================================================================\n// === MATERIALISATION SEAM ===================================================\n// The generator-function strategy lives entirely here. It is the part we're\n// least sure about: it only pays off if families are large, and a bad function\n// breaks a whole family. If it doesn't earn its keep, REPLACE THIS BLOCK with a\n// per-card renderer (ensureGenerator → no-op; apply → one LLM call per param).\n// Nothing outside this block — coordinate space, scheduler, windowing,\n// curriculum — depends on how cards get rendered.\n// ============================================================================\n\n// Guard for executing LLM-authored code. Single-tenant + own key keeps risk low;\n// the real answer at scale is a sandboxed worker. This is defence-in-depth only.\nconst BANNED =\n /\\b(fetch|Deno|globalThis|process|require|import|eval|XMLHttpRequest|constructor|setTimeout|setInterval)\\b|while\\s*\$\\s*true\\s*\$/;\n\nexport function safeBody(body: string): boolean {\n return typeof body === \"string\" && body.length > 0 && body.length < 2000 && !BANNED.test(body);\n}\n\n// Run an LLM-authored pure function body: (p) => { q, a }. Returns null on any\n// failure or malformed output, so one bad apply can't poison the batch.\nexport function runGenerator(fnBody: string, p: unknown): { q: string; a: string } | null {\n try {\n const fn = new Function(\"p\", `\"use strict\";\\n${fnBody}`);\n const out = fn(p) as { q?: unknown; a?: unknown };\n if (out && typeof out.q === \"string\" && typeof out.a === \"string\" && out.q && out.a) {\n return { q: out.q.slice(0, 160), a: out.a.slice(0, 160) };\n }\n } catch (e) {\n console.error(\"generator threw:\", String(e));\n }\n return null;\n}\n\nconst SYSTEM_AUTHOR =\n \"You author a PURE JavaScript function BODY that builds ONE flashcard from a parameters object, \" +\n \"for a child aged 6 to 8. The body receives one argument `p` and must end by returning { q, a } — \" +\n \"q the question the child answers from memory, a the short answer revealed after.\\n\" +\n \"The function MUST be parameterised: q and a are DERIVED from the fields of p. Do NOT hard-code a \" +\n \"specific question or answer — a constant function is wrong, because the same p-shape is applied to \" +\n \"many different p values to make many different cards.\\n\" +\n \"Pure only: string building and arithmetic on p. NO fetch, Deno, globals, imports, timers, or loops.\\n\" +\n 'Return JSON {\"fn\": string, \"sig\": string}: fn is the function body only (no wrapper); sig names the ' +\n \"fields of p and their types.\\n\" +\n \"Example (addition family) → \" +\n '{\"fn\":\"return { q: `${p.x} + ${p.y} = ?`, a: String(p.x + p.y) };\",\"sig\":\"{ x:int, y:int }\"}\\n' +\n \"Example (opposites family) → \" +\n '{\"fn\":\"return { q: `Opposite of ${p.word}?`, a: p.opposite };\",\"sig\":\"{ word:string, opposite:string }\"}\\n' +\n \"CRITICAL: q must NEVER contain or reveal a — no echoing, no asking to spell or say a shown word.\";\n\n// Probe a function body with two different synthetic params. A non-degenerate\n// generator varies its output; a constant one (the failure we caught) returns\n// the same card both times → reject. Generic: doesn't need the real p-shape.\nfunction isParameterised(fnBody: string, op: string): boolean {\n if (op !== \"name\") return true; // only determinate ops (arithmetic/opposites) must vary on p\n const a = runGenerator(fnBody, { x: 2, y: 3, n: 2, word: \"big\", opposite: \"small\", a: 2, b: 3 });\n const b = runGenerator(fnBody, { x: 7, y: 4, n: 9, word: \"hot\", opposite: \"cold\", a: 7, b: 4 });\n if (!a || !b) return false;\n return a.q !== b.q || a.a !== b.a;\n}\n\n// Ensure a family has a generator function; author one if missing. Rejects\n// unsafe or degenerate (constant) functions rather than saving them.\nasync function ensureGenerator(\n node: { id: number; label: string; op: string },\n example?: string,\n): Promise {\n const existing = await getGenerator(node.id, node.op);\n if (existing) return existing;\n const user = `Card family — topic: ${node.label}; task type: ${node.op}.` +\n (example ? ` Example card: ${example}` : \"\") + ` Author the generator.`;\n const a = await completeJSON<{ fn: string; sig: string }>(SYSTEM_AUTHOR, user);\n if (!a?.fn || !safeBody(a.fn) || !isParameterised(a.fn, node.op)) return null;\n await saveGenerator(node.id, node.op, a.fn, String(a.sig ?? \"\"));\n return await getGenerator(node.id, node.op);\n}\n\n// Apply the family function to params → rendered cards (pure, no LLM).\nfunction apply(gen: Generator, params: unknown[]): { p: unknown; q: string; a: string }[] {\n const out: { p: unknown; q: string; a: string }[] = [];\n for (const p of params) {\n const card = runGenerator(gen.fn, p);\n if (card) out.push({ p, ...card });\n }\n return out;\n}\n// ============================================================================\n// === END SEAM ===============================================================\n// ============================================================================\n\n// --- Curriculum (control plane): decide WHAT instances to teach -------------\nconst SYSTEM_PARAMS =\n \"You propose parameter objects for a flashcard generator, for a child aged 6 to 8. \" +\n 'Return JSON {\"params\": object[]} — new parameter objects matching the given shape, age-appropriate, ' +\n \"slightly more advanced than what is covered, with NO duplicates of the covered set.\";\n\nasync function proposeParams(\n node: { label: string; op: string; level: number },\n sig: string,\n coveredQuestions: string[],\n existingKeys: Set,\n n: number,\n): Promise {\n const user = `Topic: ${node.label}; task: ${node.op}; level: ${node.level}; parameter shape: ${sig}. ` +\n `Already covered: ${coveredQuestions.join(\" | \") || \"(none)\"}. Propose ${n} new parameter objects.`;\n const j = await completeJSON<{ params: unknown[] }>(SYSTEM_PARAMS, user);\n return (j?.params ?? []).filter((p) => !existingKeys.has(canon(p))).slice(0, n);\n}\n\n// --- The generation tick ----------------------------------------------------\nexport async function tickGenerate(opts?: { perNode?: number; force?: number; cap?: number }) {\n if (!hasKey()) return { skipped: \"no OPENAI_API_KEY set\" };\n const perNode = opts?.perNode ?? 4;\n const ready = await nodesReadyToGrow({ force: opts?.force });\n const nodes = opts?.cap ? ready.slice(0, opts.cap) : ready;\n const report: Record[] = [];\n\n for (const node of nodes) {\n if (!TEXT_OPS.has(node.op)) {\n report.push({ node: node.label, skipped: \"production op — needs audio\" });\n await recordGenLog(node.id, node.op, \"skipped\", \"production op — needs audio\");\n continue;\n }\n const seedExample = (await existingQuestions(node.id, node.op))[0];\n const gen = await ensureGenerator(node, seedExample); // SEAM\n if (!gen) {\n report.push({ node: node.label, error: \"no safe generator authored\" });\n await recordGenLog(node.id, node.op, \"error\", \"no safe generator authored\");\n continue;\n }\n const coveredQ = await existingQuestions(node.id, node.op);\n const keys = new Set(await existingParams(node.id, node.op));\n const params = await proposeParams(node, gen.sig, coveredQ, keys, perNode);\n const cards = apply(gen, params); // SEAM\n let made = 0;\n for (const c of cards) {\n if (await insertCard(node.id, node.op, canon(c.p), node.level, c.q, c.a)) made++;\n }\n report.push({ node: node.label, op: node.op, proposed: params.length, made });\n await recordGenLog(node.id, node.op, \"made\", `${made}/${params.length} cards`);\n }\n return report.length ? report : { idle: \"nothing ready to grow\" };\n}\n\n// --- Structural curriculum: subdivide a saturated leaf into four -----------\n// Distinct from card generation: this edits the SHAPE of the tree. When a leaf\n// is mastered and full, refine it into four MECE sub-quadrants and reparent its\n// cards down. The children then grow their own cards via tickGenerate.\nconst SYSTEM_SUBDIVIDE =\n \"You refine a learning topic for a child aged 6 to 8 by splitting it into EXACTLY FOUR sub-topics \" +\n \"that are mutually exclusive and together cover the topic — a clean 2×2 partition. \" +\n \"You are also given the topic's existing cards; assign each to its best-fitting sub-topic.\\n\" +\n 'Return JSON {\"children\": string[4], \"assign\": { \"\": <0-3> }}: children are the four ' +\n \"sub-topic labels in order; assign maps each given card id to its sub-topic index 0..3. Labels short.\";\n\nexport async function subdivide(node: { id: number; label: string }, cards: { id: number; q: string }[]) {\n const list = cards.map((c) => `#${c.id}: ${c.q}`).join(\"\\n\");\n const user = `Topic: ${node.label}. Existing cards:\\n${list}\\nSplit into four sub-topics and assign each card.`;\n const r = await completeJSON<{ children: string[]; assign: Record }>(SYSTEM_SUBDIVIDE, user);\n if (!r?.children || r.children.length < 2) return null;\n return await subdivideNode(node.id, r.children, r.assign ?? {});\n}\n",[],[434],"448783dc-5d47-11f1-8c21-1607ee4eb77e","db.ts","f99c90d8-5c83-11f1-b6d4-1607ee4eb77e",74,["D",1780269609882],"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\n// primer data layer: schema + seed + Leitner scheduling + the windowed session query.\n// One val-scoped SQLite DB. Generation (the cron/LLM) is NOT here yet — the\n// prototype runs on the seed grid and exercises only the *review* dynamics.\n\nexport type Grade = \"got\" | \"almost\" | \"miss\";\n\n// --- Leitner ---------------------------------------------------------------\n// Intervals by box (1..5), in ms. Box 1 = due again next session.\nconst DAY = 86_400_000;\nconst INTERVALS = [0, 0, 1 * DAY, 3 * DAY, 7 * DAY, 21 * DAY]; // index by box\n\nexport function nextBox(box: number, grade: Grade): number {\n if (grade === \"got\") return Math.min(box + 1, 5);\n if (grade === \"miss\") return 1;\n return box; // \"almost\" holds at the same box\n}\nexport function dueAt(box: number, now: number): number {\n return now + (INTERVALS[box] ?? 0);\n}\n\nconst SESSION_CAP = 12; // capped re-entry: max cards surfaced per session\nconst MASTERY_BOX = 3; // box at/above which a card counts as mastered\n\n// --- Init / seed (idempotent, once per warm instance) ----------------------\nlet ready: Promise | null = null;\nexport function init(): Promise {\n return (ready ??= setup());\n}\n\nasync function setup() {\n await sqlite.batch([\n `CREATE TABLE IF NOT EXISTS profiles (id INTEGER PRIMARY KEY, label TEXT NOT NULL)`,\n `CREATE TABLE IF NOT EXISTS nodes (id INTEGER PRIMARY KEY, parent INTEGER, label TEXT NOT NULL, ord INTEGER DEFAULT 0)`,\n `CREATE TABLE IF NOT EXISTS cards (\n id INTEGER PRIMARY KEY,\n node_id INTEGER NOT NULL,\n op TEXT NOT NULL,\n operands TEXT NOT NULL,\n level INTEGER NOT NULL DEFAULT 1,\n q TEXT NOT NULL,\n a TEXT NOT NULL,\n content_hash TEXT,\n superseded_by INTEGER,\n UNIQUE(node_id, op, operands, level)\n )`,\n `CREATE TABLE IF NOT EXISTS box_state (\n profile_id INTEGER NOT NULL,\n card_id INTEGER NOT NULL,\n box INTEGER NOT NULL DEFAULT 1,\n due_at INTEGER NOT NULL DEFAULT 0,\n PRIMARY KEY (profile_id, card_id)\n )`,\n `CREATE TABLE IF NOT EXISTS reviews (\n id INTEGER PRIMARY KEY,\n profile_id INTEGER NOT NULL,\n card_id INTEGER NOT NULL,\n grade TEXT NOT NULL,\n ts INTEGER NOT NULL\n )`,\n `CREATE TABLE IF NOT EXISTS generators (\n id INTEGER PRIMARY KEY,\n node_id INTEGER NOT NULL,\n op TEXT NOT NULL,\n fn TEXT NOT NULL,\n sig TEXT,\n created INTEGER NOT NULL,\n UNIQUE(node_id, op)\n )`,\n `CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT)`,\n `CREATE TABLE IF NOT EXISTS sim_trajectory (\n id INTEGER PRIMARY KEY,\n profile_id INTEGER NOT NULL,\n step INTEGER NOT NULL,\n nodes INTEGER, max_depth INTEGER, cards INTEGER, mastered INTEGER, subdivided INTEGER,\n ts INTEGER NOT NULL\n )`,\n `CREATE TABLE IF NOT EXISTS gen_log (\n id INTEGER PRIMARY KEY,\n node_id INTEGER, op TEXT, result TEXT, detail TEXT, ts INTEGER NOT NULL\n )`,\n ]);\n await migrateSeed();\n}\n\nconst SEED_VERSION = \"3\"; // bump to wipe + reseed structure on next deploy\n\nasync function migrateSeed() {\n const r = await sqlite.execute(`SELECT v FROM meta WHERE k = 'seed_version'`);\n if (r.rows[0]?.v === SEED_VERSION) return;\n await sqlite.batch([\n `DELETE FROM cards`,\n `DELETE FROM nodes`,\n `DELETE FROM box_state`,\n `DELETE FROM reviews`,\n `DELETE FROM generators`,\n `DELETE FROM profiles`,\n ]);\n await seed();\n await sqlite.execute({\n sql: `INSERT INTO meta (k, v) VALUES ('seed_version', ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v`,\n args: [SEED_VERSION],\n });\n}\n\nasync function seed() {\n await sqlite.batch([\n { sql: `INSERT INTO profiles (id, label) VALUES (?, ?)`, args: [1, \"Ada\"] },\n { sql: `INSERT INTO profiles (id, label) VALUES (?, ?)`, args: [2, \"Bea\"] },\n ]);\n\n // Recursive 2×2 partition. Top: four quadrants (parent NULL). One quadrant\n // (Numbers) is pre-subdivided into its own four, to show the recursion. A node\n // with children is a branch (tap to descend); a node with cards is a leaf\n // (tap to review). [id, parent, label, ord (0..3 = quadrant position)]\n const nodes: [number, number | null, string, number][] = [\n [1, null, \"Words\", 0],\n [2, null, \"Numbers\", 1],\n [3, null, \"Nature\", 2],\n [4, null, \"World\", 3],\n [21, 2, \"Counting\", 0],\n [22, 2, \"Addition\", 1],\n [23, 2, \"Subtraction\", 2],\n [24, 2, \"Comparing\", 3],\n ];\n await sqlite.batch(\n nodes.map(([id, parent, label, ord]) => ({\n sql: `INSERT INTO nodes (id, parent, label, ord) VALUES (?, ?, ?, ?)`,\n args: [id, parent, label, ord],\n })),\n );\n\n // Seed cards — retrieval ops only (name / recall-instance). The answer is\n // never present in the question. Production ops (spelling, say/compose) are\n // parked for the audio path. [node, op, operands, level, q, a]\n const cards: [number, string, string, number, string, string][] = [\n // Words → opposites\n [1, \"name\", \"opp-hot\", 1, \"Opposite of hot ?\", \"cold\"],\n [1, \"name\", \"opp-up\", 1, \"Opposite of up ?\", \"down\"],\n [1, \"name\", \"opp-fast\", 1, \"Opposite of fast ?\", \"slow\"],\n [1, \"name\", \"opp-big\", 1, \"Opposite of big ?\", \"small\"],\n // Numbers › Counting\n [21, \"name\", \"after-9\", 1, \"What comes after 9?\", \"10\"],\n [21, \"name\", \"after-19\", 1, \"What comes after 19?\", \"20\"],\n [21, \"name\", \"after-99\", 2, \"What comes after 99?\", \"100\"],\n // Numbers › Addition\n [22, \"name\", \"3+4\", 1, \"3 + 4 = ?\", \"7\"],\n [22, \"name\", \"6+5\", 1, \"6 + 5 = ?\", \"11\"],\n [22, \"name\", \"8+7\", 2, \"8 + 7 = ?\", \"15\"],\n // Numbers › Subtraction\n [23, \"name\", \"5-2\", 1, \"5 − 2 = ?\", \"3\"],\n [23, \"name\", \"10-4\", 1, \"10 − 4 = ?\", \"6\"],\n [23, \"name\", \"15-7\", 2, \"15 − 7 = ?\", \"8\"],\n // Numbers › Comparing\n [24, \"name\", \"cmp-7-4\", 1, \"Which is bigger: 7 or 4?\", \"7\"],\n [24, \"name\", \"cmp-3-8\", 1, \"Which is bigger: 3 or 8?\", \"8\"],\n // Nature → animals\n [3, \"recall-instance\", \"farm\", 1, \"Name a farm animal.\", \"e.g. cow, pig, sheep, hen\"],\n [3, \"recall-instance\", \"flies\", 1, \"Name an animal that can fly.\", \"e.g. bird, bat, butterfly\"],\n [3, \"recall-instance\", \"sea\", 1, \"Name a sea animal.\", \"e.g. fish, whale, crab\"],\n // World → everyday facts\n [4, \"name\", \"days-week\", 1, \"How many days in a week?\", \"7\"],\n [4, \"name\", \"after-mon\", 1, \"What day comes after Monday?\", \"Tuesday\"],\n [4, \"name\", \"car-wheels\", 1, \"How many wheels does a car have?\", \"4\"],\n ];\n await sqlite.batch(\n cards.map(([node, op, operands, level, q, a]) => ({\n sql: `INSERT INTO cards (node_id, op, operands, level, q, a) VALUES (?, ?, ?, ?, ?, ?)`,\n args: [node, op, operands, level, q, a],\n })),\n );\n}\n\n// --- Queries ---------------------------------------------------------------\nexport async function getProfiles() {\n const r = await sqlite.execute(`SELECT id, label FROM profiles ORDER BY id`);\n return r.rows.map((row) => ({ id: Number(row.id), label: String(row.label) }));\n}\n\nexport async function getBranches() {\n const r = await sqlite.execute(\n `SELECT id, label FROM nodes WHERE parent IS NULL ORDER BY ord`,\n );\n return r.rows.map((row) => ({ id: Number(row.id), label: String(row.label) }));\n}\n\n// The four (or fewer) quadrants at one level: children of `parentId`, or the\n// top quadrants when parentId is null. Each tile carries what the map needs —\n// branch-vs-leaf, and per-profile due / total / mastered counts.\nexport async function getChildren(profileId: number, parentId: number | null) {\n const now = Date.now();\n const where = parentId === null ? `n.parent IS NULL` : `n.parent = ${parentId}`;\n const r = await sqlite.execute({\n sql: `\n SELECT n.id, n.label, n.ord,\n (SELECT COUNT(*) FROM nodes k WHERE k.parent = n.id) AS kids,\n (SELECT COUNT(*) FROM cards x WHERE x.node_id = n.id AND x.superseded_by IS NULL) AS total,\n (SELECT COUNT(*) FROM cards x\n LEFT JOIN box_state b ON b.card_id = x.id AND b.profile_id = ?\n WHERE x.node_id = n.id AND x.superseded_by IS NULL\n AND (b.card_id IS NULL OR b.due_at <= ?)) AS due,\n (SELECT COUNT(*) FROM cards x JOIN box_state b ON b.card_id = x.id\n WHERE x.node_id = n.id AND b.profile_id = ? AND b.box >= ${MASTERY_BOX}) AS mastered\n FROM nodes n WHERE ${where} ORDER BY n.ord\n `,\n args: [profileId, now, profileId],\n });\n return r.rows.map((row) => ({\n id: Number(row.id),\n label: String(row.label),\n ord: Number(row.ord),\n branch: Number(row.kids) > 0,\n total: Number(row.total),\n due: Number(row.due),\n mastered: Number(row.mastered),\n }));\n}\n\n// The windowed session batch: cards in the chosen branch that are due (or new)\n// for this profile, oldest-due first, capped. Pre-rendered, flat for the device.\nexport async function getSessionBatch(profileId: number, branchId: number) {\n const now = Date.now();\n const r = await sqlite.execute({\n sql: `\n SELECT c.id, c.op, c.q, c.a\n FROM cards c\n LEFT JOIN box_state b ON b.card_id = c.id AND b.profile_id = ?\n WHERE c.superseded_by IS NULL\n AND (c.node_id = ? OR c.node_id IN (SELECT id FROM nodes WHERE parent = ?))\n AND (b.card_id IS NULL OR b.due_at <= ?)\n ORDER BY COALESCE(b.due_at, 0) ASC, c.level ASC, c.id ASC\n LIMIT ?\n `,\n args: [profileId, branchId, branchId, now, SESSION_CAP],\n });\n return r.rows.map((row) => ({\n id: Number(row.id),\n op: String(row.op),\n q: String(row.q),\n a: String(row.a),\n }));\n}\n\n// Apply a batch of grades: advance Leitner boxes and log reviews. Atomic.\nexport async function applyGrades(\n profileId: number,\n grades: { id: number; grade: Grade }[],\n) {\n if (!grades?.length) return 0;\n const now = Date.now();\n const ids = grades.map((g) => g.id);\n const placeholders = ids.map(() => \"?\").join(\",\");\n const cur = await sqlite.execute({\n sql: `SELECT card_id, box FROM box_state WHERE profile_id = ? AND card_id IN (${placeholders})`,\n args: [profileId, ...ids],\n });\n const boxOf = new Map(cur.rows.map((row) => [Number(row.card_id), Number(row.box)]));\n\n const stmts: { sql: string; args: unknown[] }[] = [];\n for (const g of grades) {\n const prev = boxOf.get(g.id) ?? 1;\n const nb = nextBox(prev, g.grade);\n const due = dueAt(nb, now);\n stmts.push({\n sql: `INSERT INTO box_state (profile_id, card_id, box, due_at) VALUES (?, ?, ?, ?)\n ON CONFLICT(profile_id, card_id) DO UPDATE SET box = excluded.box, due_at = excluded.due_at`,\n args: [profileId, g.id, nb, due],\n });\n stmts.push({\n sql: `INSERT INTO reviews (profile_id, card_id, grade, ts) VALUES (?, ?, ?, ?)`,\n args: [profileId, g.id, g.grade, now],\n });\n }\n await sqlite.batch(stmts);\n return grades.length;\n}\n\n// --- Generation support (pure-function model) ------------------------------\nconst NODE_CARD_CAP = 24; // ceiling on cards per node — bounds growth\n\nexport type Generator = { id: number; node_id: number; op: string; fn: string; sig: string };\n\nexport async function getGenerator(nodeId: number, op: string): Promise {\n const r = await sqlite.execute({\n sql: `SELECT id, node_id, op, fn, sig FROM generators WHERE node_id = ? AND op = ?`,\n args: [nodeId, op],\n });\n if (!r.rows.length) return null;\n const row = r.rows[0];\n return {\n id: Number(row.id),\n node_id: Number(row.node_id),\n op: String(row.op),\n fn: String(row.fn),\n sig: String(row.sig ?? \"\"),\n };\n}\n\nexport async function saveGenerator(nodeId: number, op: string, fn: string, sig: string): Promise {\n await sqlite.execute({\n sql: `INSERT INTO generators (node_id, op, fn, sig, created) VALUES (?, ?, ?, ?, ?)\n ON CONFLICT(node_id, op) DO UPDATE SET fn = excluded.fn, sig = excluded.sig, created = excluded.created`,\n args: [nodeId, op, fn, sig, Date.now()],\n });\n}\n\n// Canonical param strings already materialised for this family (for DRY dedup).\nexport async function existingParams(nodeId: number, op: string): Promise {\n const r = await sqlite.execute({\n sql: `SELECT operands FROM cards WHERE node_id = ? AND op = ?`,\n args: [nodeId, op],\n });\n return r.rows.map((row) => String(row.operands));\n}\n\n// Existing rendered questions for this family (human-readable, to steer the\n// proposer away from semantic duplicates of the seed cards).\nexport async function existingQuestions(nodeId: number, op: string): Promise {\n const r = await sqlite.execute({\n sql: `SELECT q FROM cards WHERE node_id = ? AND op = ? AND q != ''`,\n args: [nodeId, op],\n });\n return r.rows.map((row) => String(row.q));\n}\n\n// Insert a materialised card. DRY on TWO axes: the UNIQUE coordinate (param\n// space) AND a content hash of the rendered q|a (output space). The second\n// guard is what stops a degenerate/constant generator from emitting the same\n// card under different params — the failure the dashboard caught.\nexport async function insertCard(\n nodeId: number,\n op: string,\n operands: string,\n level: number,\n q: string,\n a: string,\n): Promise {\n const hash = `${q}\\u0000${a}`.trim().toLowerCase();\n const dup = await sqlite.execute({\n sql: `SELECT 1 FROM cards WHERE node_id = ? AND op = ? AND content_hash = ? LIMIT 1`,\n args: [nodeId, op, hash],\n });\n if (dup.rows.length) return false; // identical rendered content already exists\n const r = await sqlite.execute({\n sql: `INSERT OR IGNORE INTO cards (node_id, op, operands, level, q, a, content_hash) VALUES (?, ?, ?, ?, ?, ?, ?)`,\n args: [nodeId, op, operands, level, q, a, hash],\n });\n return (r.rowsAffected ?? 0) > 0;\n}\n\n// Nodes whose current cards are fully mastered and under the cap — the frontier\n// is solid, so the ladder may unfold. New (unmastered) cards then block regrowth\n// until they too are learned. `force` bypasses the gate for on-demand testing.\nexport async function nodesReadyToGrow(opts?: { force?: number }) {\n const r = await sqlite.execute(`\n SELECT n.id, n.label,\n (SELECT op FROM cards WHERE node_id = n.id GROUP BY op ORDER BY COUNT(*) DESC LIMIT 1) AS op,\n (SELECT COALESCE(MAX(level), 1) FROM cards WHERE node_id = n.id) AS level,\n (SELECT COUNT(*) FROM cards WHERE node_id = n.id) AS filled,\n (SELECT COUNT(DISTINCT c.id) FROM cards c JOIN box_state b ON b.card_id = c.id\n WHERE c.node_id = n.id AND b.box >= ${MASTERY_BOX}) AS mastered\n FROM nodes n\n `);\n const all = r.rows.map((row) => ({\n id: Number(row.id),\n label: String(row.label),\n op: row.op ? String(row.op) : \"name\",\n level: Number(row.level),\n filled: Number(row.filled),\n mastered: Number(row.mastered),\n }));\n if (opts?.force) return all.filter((n) => n.id === opts.force);\n return all.filter((n) => n.filled > 0 && n.filled < NODE_CARD_CAP && n.mastered >= n.filled);\n}\n\n// --- Simulation + structural growth support --------------------------------\n\n// Cards not yet mastered (or never seen) by this profile — what the simulated\n// learner still needs to practise. Lowest box first, capped per step.\nexport async function simReviewSet(profileId: number, limit: number) {\n const r = await sqlite.execute({\n sql: `\n SELECT c.id, c.node_id, COALESCE(b.box, 0) AS box FROM cards c\n LEFT JOIN box_state b ON b.card_id = c.id AND b.profile_id = ?\n WHERE c.superseded_by IS NULL AND COALESCE(b.box, 0) < ${MASTERY_BOX}\n ORDER BY COALESCE(b.box, 0) ASC, c.id ASC\n LIMIT ?\n `,\n args: [profileId, limit],\n });\n return r.rows.map((row) => ({ id: Number(row.id), node: Number(row.node_id), box: Number(row.box) }));\n}\n\n// All nodes (id, parent, label) — caller computes depth / leaf-ness in JS.\nexport async function simNodes() {\n const r = await sqlite.execute(`SELECT id, parent, label FROM nodes`);\n return r.rows.map((row) => ({\n id: Number(row.id),\n parent: row.parent === null ? null : Number(row.parent),\n label: String(row.label),\n }));\n}\n\n// Per-node card + mastered counts for a profile (mastered = box >= MASTERY_BOX).\nexport async function nodeCardStats(profileId: number) {\n const r = await sqlite.execute({\n sql: `\n SELECT n.id,\n (SELECT COUNT(*) FROM cards x WHERE x.node_id = n.id AND x.superseded_by IS NULL) AS cards,\n (SELECT COUNT(*) FROM cards x JOIN box_state b ON b.card_id = x.id\n WHERE x.node_id = n.id AND b.profile_id = ? AND b.box >= ${MASTERY_BOX}) AS mastered\n FROM nodes n\n `,\n args: [profileId],\n });\n return r.rows.map((row) => ({ id: Number(row.id), cards: Number(row.cards), mastered: Number(row.mastered) }));\n}\n\n// Cards (id + question) attached directly to a node.\nexport async function cardsOfNode(nodeId: number) {\n const r = await sqlite.execute({\n sql: `SELECT id, q FROM cards WHERE node_id = ? AND superseded_by IS NULL`,\n args: [nodeId],\n });\n return r.rows.map((row) => ({ id: Number(row.id), q: String(row.q) }));\n}\n\n// Structural growth: turn a leaf into a branch of four sub-quadrants, and move\n// the leaf's existing cards down into their assigned child. The curriculum act —\n// it edits the *shape* of the tree, not its cards. Additive (append children).\nexport async function subdivideNode(\n parentId: number,\n labels: string[],\n assignment: Record, // cardId -> child index 0..3\n) {\n const four = labels.slice(0, 4);\n while (four.length < 4) four.push(`Area ${four.length + 1}`);\n for (let i = 0; i < 4; i++) {\n await sqlite.execute({\n sql: `INSERT INTO nodes (parent, label, ord) VALUES (?, ?, ?)`,\n args: [parentId, four[i], i],\n });\n }\n const kids = await sqlite.execute({\n sql: `SELECT id FROM nodes WHERE parent = ? ORDER BY ord`,\n args: [parentId],\n });\n const childIds = kids.rows.map((row) => Number(row.id));\n\n const cards = await cardsOfNode(parentId);\n const stmts = cards.map((c) => {\n const idx = Math.max(0, Math.min(3, assignment[String(c.id)] ?? 0));\n return { sql: `UPDATE cards SET node_id = ? WHERE id = ?`, args: [childIds[idx], c.id] };\n });\n // The parent's generator no longer applies; children author their own.\n stmts.push({ sql: `DELETE FROM generators WHERE node_id = ?`, args: [parentId] });\n await sqlite.batch(stmts);\n return { parentId, children: childIds.map((id, i) => ({ id, label: four[i] })) };\n}\n\n// Persisted simulation trajectory (so long runs survive across resumable steps\n// and the growth curve can be charted).\nexport async function recordTrajectory(profileId: number, snap: Record) {\n await sqlite.execute({\n sql: `INSERT INTO sim_trajectory (profile_id, step, nodes, max_depth, cards, mastered, subdivided, ts)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,\n args: [profileId, snap.step, snap.nodes, snap.maxDepth, snap.cards, snap.mastered, snap.subdivided ?? 0, Date.now()],\n });\n}\n\nexport async function lastStep(profileId: number): Promise {\n const r = await sqlite.execute({\n sql: `SELECT COALESCE(MAX(step), 0) AS s FROM sim_trajectory WHERE profile_id = ?`,\n args: [profileId],\n });\n return Number(r.rows[0].s);\n}\n\nexport async function getTrajectory(profileId: number) {\n const r = await sqlite.execute({\n sql: `SELECT step, nodes, max_depth, cards, mastered, subdivided FROM sim_trajectory WHERE profile_id = ? ORDER BY step`,\n args: [profileId],\n });\n return r.rows.map((row) => ({\n step: Number(row.step),\n nodes: Number(row.nodes),\n maxDepth: Number(row.max_depth),\n cards: Number(row.cards),\n mastered: Number(row.mastered),\n subdivided: Number(row.subdivided),\n }));\n}\n\nexport async function resetTrajectory(profileId: number) {\n await sqlite.execute({ sql: `DELETE FROM sim_trajectory WHERE profile_id = ?`, args: [profileId] });\n}\n\n// Generation log — every attempt's outcome (made / skipped / error), so failures\n// surface in the dashboard instead of vanishing into a silent no-op.\nexport async function recordGenLog(nodeId: number, op: string, result: string, detail: string) {\n await sqlite.execute({\n sql: `INSERT INTO gen_log (node_id, op, result, detail, ts) VALUES (?, ?, ?, ?, ?)`,\n args: [nodeId, op, result, detail, Date.now()],\n });\n}\n\nexport async function getGenLog(limit = 15) {\n const r = await sqlite.execute({\n sql: `SELECT g.node_id, COALESCE(n.label, '(removed)') AS node, g.op, g.result, g.detail\n FROM gen_log g LEFT JOIN nodes n ON n.id = g.node_id ORDER BY g.id DESC LIMIT ?`,\n args: [limit],\n });\n return r.rows.map((row) => ({\n node: String(row.node),\n op: String(row.op ?? \"\"),\n result: String(row.result),\n detail: String(row.detail ?? \"\"),\n }));\n}\n",[],[442],"aeb1d7ba-5cd1-11f1-aac7-1607ee4eb77e","cron_generate.ts","aeb1d86e-5cd1-11f1-aac7-1607ee4eb77e",22,["D",1780219107386],"interval","import { tickGenerate } from \"./gen.ts\";\n\n// Background generation. Runs on a schedule (set the cadence in the val's\n// settings — e.g. hourly). Cheap because materialisation is a pure function;\n// no-ops without an OPENAI_API_KEY. Incremental + invisible, by design.\nexport default async function () {\n const r = await tickGenerate();\n console.log(\"primer generate:\", JSON.stringify(r));\n}\n",[],[450],"f10646ca-5d47-11f1-be99-1607ee4eb77e","SPEC.md","d42f2eb6-5c81-11f1-9562-ee650bb23af1",85,["D",1780269899283],3,"# primer — design spec\n\nThe detailed design behind `README.md`. Sections are roughly independent; the load-bearing ideas are the **coordinate space** (§2) and the **three-component decomposition** (§1).\n\n## 0. Status (as-built) — read this first\n\nThe sections below are the original design intent. This section records what is **actually built** and where reality diverged or taught us something. When they conflict, this section wins.\n\n**Built and working:** the device simulator (`/`, a 296×416 monochrome capacitive panel), the two-call review API, Leitner review, **card generation** (generator-function model), **structural curriculum** (`subdivide`), the **admin dashboard** (`/admin`), and a **resumable speed-run simulator**.\n\n**Deltas from the original design:**\n\n- **The grid is an explicit recursive 2×2 quadtree.** Each level is a forced four-way MECE partition; the screen's 2×2 tile grid *is* the branching factor. A leaf **subdivides into four** when it is full and mastered, so tree **depth encodes the mastery frontier** — deepest where the child has learned most. Navigation is capacitive tap-to-descend; the path you tap into *is* the interest window (§2's \"windowing\" made concrete).\n- **Operations cut to retrieval-only.** Live ops are `name` and `recall-instance` — the text-honest ones, where the answer can be withheld from the prompt. `recognise`/`contrast` (need answer input) and `compose`/spelling/`say` (need to withhold a shown word — impossible in text) are **gated by modality** and deferred to the audio path. Generation refuses non-text ops.\n- **Materialisation = a pure generator function per family.** The LLM authors `(p) => {q,a}` once per `(node, op)` family; cards are that function applied to many params (arithmetic computed in code, never hallucinated). Quarantined behind the **MATERIALISATION SEAM** in `gen.ts` so it can be swapped for per-card rendering if families prove too small. Observed yields: 4–8 cards/family — large enough to justify the machinery.\n\n**Lessons (bugs found, mostly via the dashboard — now invariants):**\n\n1. **DRY must hold in output space, not just param space.** A constant generator emitted the same card under four different params; the param-coordinate UNIQUE saw four distinct rows. Fix: dedup also on `content_hash` of rendered `q|a`. The §2 claim \"duplication is structurally impossible\" is only true with *both* guards.\n2. **Reject degenerate (constant) generators — but only for determinate ops.** A probe feeds two different params and requires different output. This must be scoped to `name` (arithmetic/opposites); `recall-instance` is open by design (\"name an animal that flies\" is the same across params) and was being wrongly rejected. *Residual brittleness:* the probe still guesses param field names, so some `name` families fail with \"no safe generator\"; the proper fix is to have the author return its own example params to probe with.\n3. **Generators are transient; cards are durable.** `subdivide` deletes the parent's generator (its cards reparent to children). So the generation-review lens derives from **cards grouped by family**, never from the generators table.\n4. **Log every generation outcome.** A rejected generator made `tickGenerate` a silent no-op inside the sim. `gen_log` now records made/skipped/error so failures surface on the dashboard.\n\n**Execution reality:** generation runs via a forced admin endpoint (`POST /api/admin/generate/:nodeId`) and the resumable sim — **not** the cron. The cron exists but is **inert** (no cadence set) by design, until the loop is trusted to run unattended. The OpenAI key is a Val.town secret (server-side), as §4 intends.\n\n**Observability — the admin dashboard (`/admin`)**, a deliberately rich surface (full colour, *not* the device bezel): domain-exploration tree with mastery bars, Leitner box histogram, friction table (missed/stuck cards), generation review (per-family yield + duplicate flag + newest-cards leak check), a growth-over-time chart, and the generation log.\n\n**The speed-run simulator** compresses use+generation+growth into steps (`POST /api/admin/sim-step/:profile`, resumable, one step per call, persisting a `sim_trajectory` snapshot). Real Leitner *spacing* is compressed away; box transitions still follow the real rules. It mutates the real (shared) DB, so it grows the actual tree; `SEED_VERSION` bump = wipe+reseed.\n\n**Known weak points (the frontier):** curriculum is the weak link, not the renderer — level-laddering is uneven and proposer-dependent, and subdivision labels collide across sibling branches because the partition prompt sees only the local topic, not its aunts/uncles. The sim is **not isolated** — concurrent runs stomp the shared DB. Multi-profile subdivision policy is undecided (tree shared, mastery per-child — who triggers a split?). See §6.\n\n## 1. Architecture\n\n### One substrate, three readers\n\nThe shared thing is the **card state** — every card, its coordinate, and per-child review history. Three components observe it independently and act at their own tempo. They never call each other; they coordinate only through the shared state. A blackboard, not a pipeline.\n\n- **Scheduler** (timing) — reads review history, decides what is *ripe*. Per-card, global, topic-blind.\n- **Curriculum** (structure) — reads the whole grid plus mastery and attention; extends the *coordinate space* (new nodes, operands, ladder rungs). Slow, global, low-volume. The control plane.\n- **Cards** (surface) — reads one empty coordinate, renders it. Fast, local, parallel, contextless. The data plane.\n\n### The coordinate space is the seam\n\nCurriculum lays down empty addressable slots; the card process consumes them; the scheduler times whatever exists. None talk directly — the coordinate space *is* the medium between them. Stigmergic: mark where a cell should be, let another component build it.\n\n### Invariant — structure is additive\n\nCurriculum **appends** to the coordinate space; it never mutates or deletes a live slot. A concept that turns out wrong is **superseded**, not deleted — a rarer, deliberate act. Append-only structure means the card process always sees a consistent, monotonically growing space, and the components never race. (Monotone growth ⇒ no coordination needed — the CALM intuition.)\n\n### Federation with Mochi\n\nprimer is a **self-contained val** — own SQLite, own generation, forkable alone. Mochi is its own substrate (an LLM pet with memory and ChatGPT-realtime voice). The **device** stitches them into one world; primer is reached through a *zone* in the pet's world. The zone is the seam — no shared backend.\n\n**Separate for now.** A later, deliberate coupling: the child's progress and current interests feed Mochi's context, so the pet knows what she's learning. That is the one link between the substrates, so it stays an explicit future choice.\n\n### Partitioning\n\nState is per child. The **tree is shared** — one coordinate space both daughters climb — but mastery, Leitner boxes, and the interest window are per child. The 8-year-old lives higher up the same ladders the 6-year-old climbs toward.\n\nAuth is **device-scoped** (bearer token). The **profile (child) is named per request** — one device serves either daughter; the token only gates access to the substrate.\n\n## 2. Data model\n\n### The grid (tech-tree)\n\nA **low-n, shallow** tree: categories → subcategories (nodes). Hand-seeded skeleton; curriculum deepens it. Low-n is load-bearing, not just minimal — it keeps the recombination space small enough that combinations stay coherent.\n\nNavigation is **self-directed**: across branches the child roams free (interest); within a branch, depth is **mastery-ordered** (count to 5 before count to 10). A sustained period of interest makes progress along that branch.\n\n### The card coordinate\n\n (node, operation, operands, level)\n\n- **node** — location in the grid (e.g. `numbers/addition`).\n- **operation** — cognitive template, a small fixed set (below).\n- **operands** — from the node's mastered-primitive vocabulary (words, numbers).\n- **level** — ladder rung.\n\nA **UNIQUE constraint on this tuple enforces DRY**: a proposed card whose coordinate exists fails to insert. Duplication is structurally impossible, not merely discouraged.\n\nA \"harder version of a similar question\" is **not** a near-duplicate — it is a *different coordinate by design* (same operands, higher operation or level). `(colour, name, apple, L1)` and `(colour, recall-instance, {red,3}, L2)` are different addresses. The structure encodes redundant-vs-progressive instead of asking similarity to guess.\n\n### Operations\n\nCognitive templates: `recognise · name · recall-instance · compose · contrast`. This set also doubles as the device's layout vocabulary (§5).\n\n**Note — reconcile with the 3-button grade model (§3).** Recall-style ops (`name`, `recall-instance`, `compose`) fit cleanly: attempt → reveal → self-grade with the three buttons. Answer-selection ops (`recognise`, `contrast`) want answer *input*, which contends for those same buttons — so they are likely **deferred** until there is a separate answer-input affordance (or the audio path). The prototype can ship recall-style only.\n\n### MECE as coverage\n\n- **Mutually exclusive** — unique coordinates plus a curated primitive vocabulary (no synonym primitives; `puppy` and `dog` as separate atoms would slip a real duplicate past the coordinate).\n- **Collectively exhaustive** — a *query*: which eligible slots in the active branch are empty? That set is the generator's worklist.\n\n### Tables (sketch)\n\n- `profiles` — children; id, label.\n- `nodes` — the grid; id, parent, label, order.\n- `operands` — per-node vocabulary; node_id, token.\n- `cards` — id, node_id, operation, operands (canonical), level, q (rendered), a (rendered), opts (rendered; recognition only), content_hash, superseded_by. `UNIQUE(node_id, operation, operands, level)`.\n- `reviews` — profile_id, card_id, grade, ts.\n- `box_state` — profile_id, card_id, leitner_box, due_at.\n- `mastery` — profile_id, node_id/operand, mastered_at (gates ladders and recombination).\n- `attention` — profile_id, node_id, rolling weight (drives windowing, with hysteresis).\n\n`content_hash` is a canonical-form hash of the rendered question — a cheap backstop for surface dupes from overlapping templates. Embeddings, if ever used, are a *same-coordinate* collision flag only, never a cross-card filter (that would eat the ladder).\n\n## 3. Review — grading, scheduling, windowing\n\n### Grading — three-button self-report\n\nThe child grades herself: **got it / almost / didn't know** — hardware-native on a three-button device. (At 6 and 8 they read the labels; `almost` still blurs toward `got it` for the younger — don't over-trust the middle.)\n\nThe **sequence is load-bearing**: attempt → reveal → grade. She must commit to a recall attempt *before* the answer appears, or the grade is noise.\n\nSelf-report is a **soft signal** — kids over-report. Generation treats it as *evidence, not truth*: several consistent `got it`s before laddering up, never one.\n\n**Deferred — audio judging.** The device has audio in/out (ChatGPT-realtime, Mochi side). A *spoken* answer captured before reveal makes the pre-commit real and recorded, and an LLM judge turns the grade from a claim into verification. But it puts the key on the *review* path (a call per answer, latency, cost), so adopt it **selectively** — occasional judging to *calibrate* self-report against ground truth, buttons the rest of the time.\n\n### Scheduling — Leitner\n\nLeitner boxes, over SM-2, for legibility, kid-fit, and a clean mastery signal (top box ⇒ trigger laddering/recombination).\n\nGrade → transition: `got it` promotes, `didn't know` demotes to box 1, `almost` holds. The three grades map onto the three generation moves: `didn't know` → scaffold down, `almost` → hold and add a near-variant, sustained `got it` → ladder up or recombine.\n\nThe scheduler is **independent and global** — per-card, decides what is *ripe*, topic-blind.\n\n### Windowing — self-direction over the ripe set\n\nSelf-direction is a **lens over scheduled content**, not a separate session generator. A card surfaces when it is both **due** (scheduler) and **in the interest window** (branch in focus). Dormant branches still go due but never enter a session — the window is elsewhere.\n\n**Hard window** is the default — purest self-direction, simplest. Wrinkle: returning to a long-dormant branch surfaces a backlog at once, rough for a child. Mitigation: **capped re-entry** — a limit on stale cards per session, or a warm-up.\n\n**Within-session stability, between-session adaptation** — window and generation recompute on the cron *between* sessions, so difficulty never shifts under the child mid-flow.\n\n## 4. Generation\n\nTwo parallel processes, split because global-awareness work and high-volume work are *different* work. Conflating them produces repetitive content.\n\n### Curriculum (control plane)\n\nSlow, global, low-volume. Reads the **whole grid** (small — low-n fits in context) plus mastery and attention; emits **structural edits**: a sub-node, new operands, a ladder rung. The model's judgement about the shape of knowledge lives here, and DRY/MECE are enforced here — it sees everything because everything is small. Edits are **additive**; retraction is **supersede** (§1).\n\n**Triggers** (not every tick): a mastery milestone (node mostly mastered → extend), sustained attention crossing the hysteresis line (deepen the attended branch), or the active region running out of empty slots.\n\n### Cards (data plane)\n\nFast, local, parallel. A pure function from one empty coordinate to a rendered card. **Sees no other card** — the coordinate guarantees uniqueness — so it cannot duplicate. The model does *surface realisation only*: phrasing, distractor choice. Could be a cheaper model. Each tick **fills one slot**, then idles when the region is covered.\n\nGeneration emits small **learning units** (teach card + tests), not bare flashcards — introduce material before quizzing (the Quantum Country move).\n\n### Why the context problem dissolves\n\nYou never send existing cards. Curriculum sends the whole (small) grid; the card process gets specific *empty* coordinates plus the (small) operand vocabulary. Existing cards are structurally unaddressable as targets, so context stays O(gap-list) regardless of deck size.\n\n### Distractors sit on the seam\n\n\"What are the wrong answers\" is more structural than free — draw distractors from the operand vocabulary; don't let the card process invent them, or they get repetitive or absurd. (Applies to recognition ops.)\n\n### Execution — key and cron\n\n> **As-built (see §0):** generation runs via a forced admin endpoint and the resumable simulator, **not** the cron. The cron exists but is inert until trusted. The structural-curriculum process (`subdivide`) is built; the card process uses the generator-function model behind the materialisation seam. What follows is the intended steady state.\n\nGeneration runs **server-side** on a Val.town cron (interval val). The OpenAI key is a **Val.town secret**.\n\nA deliberate trade of the \"no keys on server\" posture — justified for a *private family* substrate on own infra, unlike the giftable Mochi case where that posture is load-bearing. The win: true background generation, matching the original \"periodic consolidation\" intent.\n\n**BYO-key cost shape**: a few expensive structural passes (curriculum) plus many tiny cheap renders (cards) — not many expensive calls each straining to see everything.\n\n## 5. API & device\n\n### Auth\n\nBearer token in `Authorization`. **Device-scoped, not child-scoped** — gates the substrate; the profile is named per request. A deliberate step down from sync's OAuth/passkeys, fit for a private device.\n\n### Efficient query — session-batched, not card-streamed\n\nePaper round-trips are slow, so the device does not fetch per card.\n\n- `GET /session?profile=…` → one **session batch**: the windowed due cards (small, by construction). Each card **pre-rendered** (ready-to-draw strings; the device never templates).\n- The device walks the batch **offline** — render, flip, capture grade.\n- `POST /grades` → all grades in one request at session end.\n\nOne fetch, one post. The server consolidates afterwards on its cron.\n\n### Payload — pre-rendered, flat, parser-friendly\n\nShaped for ArduinoJson: short flat keys, no deep nesting, strings rendered server-side. A card is roughly:\n\n { \"id\": 12, \"op\": \"name\", \"q\": \"…\", \"a\": \"…\" }\n\n`op` is the operation tag; `opts` appears only for recognition-style ops.\n\n### Procedural UI — the middle path\n\nThe device parses the batch and procedurally generates UI. Two extremes: *lean* (payload carries `op` + strings; device owns a fixed layout per operation — the low-n template set is the layout vocabulary; UI evolution needs a firmware flash) and *generic* (server sends an explicit widget list; UI evolves without a flash, at a heavier payload/interpreter).\n\n**Chosen: the middle** — a small declarative payload (`op` + strings + ids) read by a **fixed widget interpreter**. The low-n stable operation set makes the lean coupling cheap, while the interpreter stays generic enough to grow.\n\nUse **partial refresh** for front→back so only the reveal region redraws (full-refresh ghosts and is slow).\n\n### The zone\n\nprimer is reached through a **zone in Mochi's world**. Entering hands control to the embedded primer client (which talks to this API); leaving returns to the pet. The zone is the only integration point.\n\n## 6. Open / deferred\n\n*Resolved this build (see §0):* the silent generation no-op is now logged (`gen_log`); output-space duplication is closed (`content_hash`); the degeneracy gate no longer rejects open ops.\n\n- **Generator probe brittleness** — the degeneracy check guesses param field names, so some determinate (`name`) families fail with \"no safe generator\". Fix: have the author return its own example params and probe with those.\n- **Curriculum quality, not renderer** — level-laddering is uneven and proposer-dependent (Addition laddered; opposites stayed flat). And subdivision labels collide across sibling branches because the partition prompt sees only the local topic — give it the surrounding map.\n- **Self-driving sim** — the speed-run still needs a human clicking step-by-step; a run-N-steps that respects the request timeout wants the cron or a queue.\n- **Sim isolation** — concurrent runs mutate the same shared DB and stomp each other; a run needs its own scope (or a lock).\n- **Multi-profile subdivision policy** — tree shared, mastery per-child; decide who triggers a split (leading child? any?).\n- **Operation set vs buttons** (§2/§3) — recall-style ops shipped; `recognise`/`contrast` deferred pending an answer-input affordance.\n- **Audio judging** (§3) — selective calibration of self-report; would unlock production ops (spelling/`say`); not built.\n- **Pet-context coupling** (§1) — progress/interests → Mochi's memory; explicit future choice, the one thing that links the substrates.\n- **Cold start** — who authors the initial grid skeleton and seed primitives (currently hand-seeded in `db.ts`).\n- **Shared-device profile selection** — the in-world \"who's playing\" before the zone loads (the sim already does tap-to-pick).\n",[],[459],"f8b33c98-5d47-11f1-98bf-1607ee4eb77e","README.md","b3ef1c9c-5c81-11f1-90de-ee650bb23af1",["D",1780269912147],"# primer\n\nA self-contained spaced-repetition substrate for children, embedded as a zone in the Mochi virtual pet. Cards are generated and consolidated in the background; the deck unfolds along the child's interests rather than following a fixed curriculum.\n\n> Working name — _primer_, after the Young Lady's Illustrated Primer (Diamond Age): an adaptive book that teaches a child and grows with her. Rename freely.\n\n## Lineage\n\n- **Anki / spaced repetition** — the retention engine (Leitner boxes).\n- **Quantum Country** — cards as a mnemonic medium. Generation emits small *learning units* (a teach card + its tests), not bare flashcards.\n- **Diamond Age primer** — adaptive, child-directed, grows with the learner.\n- **Substrate thesis** — one shared card state; independent self-activating components (scheduler, curriculum, cards) observe it and act at their own tempo. Coordination is stigmergic, through the shared coordinate space, not message-passing.\n\n## Who and what\n\n- Two readers, 6 and 8. One shared tree; each climbs to her own depth, gated by her own mastery. State partitioned per child.\n- Form factor: the Mochi device — ESP32 + ePaper. Monochrome, slow refresh, a few buttons, audio in/out. Text-centric: written question, text reveal, graded by button. Content gravitates to text-symbolic domains — arithmetic, spelling, vocabulary, factual recall.\n\n## The core loop\n\n1. Child picks a profile, then taps down through the **knowledge map** — a recursive 2×2 partition of quadrants; tap a branch to descend, a leaf to study. The path she taps into is her interest window.\n2. Device fetches one **session batch** of due cards for that leaf over a bearer-token API.\n3. Per card: attempt → reveal → grade (got it / almost / didn't know). Graded **offline**, on-device.\n4. Device posts all grades back in one request at session end.\n5. The server consolidates: updates Leitner boxes, generates cards on mastered leaves, and **subdivides** a leaf into four sub-quadrants once it is full and mastered — so the tree deepens where she has learned most.\n\nAdaptation lands one session later by design — stable within a session, adaptive between them.\n\n## Status\n\nWorking prototype. Built: device simulator (`/`), the two-call review API, Leitner review, card generation + structural subdivision, an admin dashboard (`/admin`), and a resumable speed-run simulator. Generation runs on demand / via the simulator; the background cron is wired but inert until trusted.\n\n`SPEC.md` holds the design — **start with its §0 (Status / as-built)**, which records what is actually built, where it diverged, and the bugs-turned-invariants found along the way.\n",[],[468],"439e3070-5cc4-11f1-8455-1607ee4eb77e","index.tsx","439e3138-5cc4-11f1-8455-1607ee4eb77e",14,["D",1780213344285],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { createRoot } from \"https://esm.sh/react-dom@18.2.0/client\";\nimport { App } from \"./components/App.tsx\";\n\nconst root = document.getElementById(\"root\");\nif (!root) throw new Error(\"No root element found\");\ncreateRoot(root).render();\n",[],[307,475],"46231c52-5cc4-11f1-ac2d-1607ee4eb77e","index.html","46231d24-5cc4-11f1-ac2d-1607ee4eb77e",15,["D",1780213348502],"\n\n \n \n \n primer — device prototype\n \n \n \n

\n \n \n \n\n",[],[307,483],"34f6bc1e-5cc8-11f1-aad0-1607ee4eb77e","device.ts","0fc5dbd6-5cc4-11f1-b9e7-1607ee4eb77e",16,["D",1780215037675],"// The device envelope. Every UI component reads from here, so the web\n// prototype can never accidentally exceed what the ePaper + ESP32 will do.\n// When real hardware specs land, change them HERE and the whole sim follows.\n\nexport const DEVICE = {\n // ePaper panel, portrait. Logical px ~= device px at 1x.\n screen: { w: 296, h: 416 },\n\n // Monochrome only. No colour is reachable on the panel — the sim renders\n // strictly in these two inks so we never design something we can't ship.\n ink: \"#111111\",\n paper: \"#f4f4ee\",\n\n // Capacitive touch on the eInk panel — tap is a real device gesture, not a\n // sim-only convenience. So tapping the card to reveal is faithful.\n touch: true,\n // Three physical buttons, which map exactly to the grade taxonomy.\n // (Touch also unlocks the deferred selection ops — recognise/contrast — later.)\n buttons: 3,\n\n // ePaper is slow. Simulated refresh delays make the rhythm honest:\n // full refresh flashes and is slow; partial refresh (the card flip) is quicker.\n refresh: { full: 700, partial: 200 },\n} as const;\n\n// The three buttons, in fixed order. Doubles as the grade vocabulary.\nexport const GRADES = [\n { key: \"miss\", label: \"Didn't know\" },\n { key: \"almost\", label: \"Almost\" },\n { key: \"got\", label: \"Got it\" },\n] as const;\n\nexport type GradeKey = (typeof GRADES)[number][\"key\"];\n\n// Bearer token. In the sim it's the dev token; on device it's provisioned to\n// firmware. Never entered through this UI — it models a device credential.\nexport const DEVICE_TOKEN = \"dev-token\";\n",[],[307,491],"ea6b3bd2-5d41-11f1-985b-1607ee4eb77e","api.ts","154c8988-5cc4-11f1-a41f-1607ee4eb77e",41,["D",1780267311199],"import { DEVICE_TOKEN, type GradeKey } from \"./device.ts\";\n\n// Models the device's entire network surface: two calls per session.\n// Fetch one batch, post the buffered grades. No per-card round trips.\n\nexport type Card = { id: number; op: string; q: string; a: string };\nexport type Profile = { id: number; label: string };\nexport type Branch = { id: number; label: string };\n\nconst auth = { Authorization: `Bearer ${DEVICE_TOKEN}` };\n\nasync function get(path: string): Promise {\n const r = await fetch(path, { headers: auth });\n if (!r.ok) throw new Error(`${path} → ${r.status}`);\n return r.json();\n}\n\nexport async function fetchProfiles(): Promise {\n return (await get<{ profiles: Profile[] }>(\"/api/profiles\")).profiles;\n}\n\nexport async function fetchBranches(): Promise {\n return (await get<{ branches: Branch[] }>(\"/api/branches\")).branches;\n}\n\nexport type Quadrant = {\n id: number;\n label: string;\n ord: number;\n branch: boolean; // has sub-quadrants (descend) vs leaf (review)\n total: number;\n due: number;\n mastered: number;\n};\n\n// The quadrants at one level: children of `parent`, or the top four for \"root\".\nexport async function fetchQuadrants(profile: number, parent: number | \"root\"): Promise {\n return (await get<{ quadrants: Quadrant[] }>(`/api/quadrants/${profile}/${parent}`)).quadrants;\n}\n\n// One fetch at session start: the windowed due batch for this profile + branch.\nexport async function fetchSession(profile: number, branch: number): Promise {\n return (await get<{ cards: Card[] }>(`/api/session/${profile}/${branch}`)).cards;\n}\n\n// One post at session end: all buffered grades together.\nexport async function postGrades(\n profile: number,\n grades: { id: number; grade: GradeKey }[],\n): Promise {\n const r = await fetch(\"/api/grades\", {\n method: \"POST\",\n headers: { ...auth, \"Content-Type\": \"application/json\" },\n body: JSON.stringify({ profile, grades }),\n });\n if (!r.ok) throw new Error(`/api/grades → ${r.status}`);\n return (await r.json()).applied;\n}\n",[],[307,499],"3a61eae0-5d43-11f1-ad23-1607ee4eb77e","admin.tsx","3a61ebc6-5d43-11f1-ad23-1607ee4eb77e",48,["D",1780267874874],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { createRoot } from \"https://esm.sh/react-dom@18.2.0/client\";\nimport { Dashboard } from \"./components/Dashboard.tsx\";\n\nconst root = document.getElementById(\"root\");\nif (!root) throw new Error(\"No root element found\");\ncreateRoot(root).render();\n",[],[307,507],"3831e5fe-5d43-11f1-83b5-1607ee4eb77e","admin.html","3831e6da-5d43-11f1-83b5-1607ee4eb77e",47,["D",1780267871207],"\n\n \n \n \n primer — admin\n \n \n \n

\n \n \n \n\n",[],[307,515],["D",1780213311908],[],[307,222,113],["D",1780267296707],[],[307,222,149],["D",1780213320815],[],[307,222,122],["D",1780213275215],[],[307,222,80],["D",1780267305545],[],[307,222,158],["D",1780269810498],[],[307,222,176],["D",1780219028733],[],[307,222,104],["D",1780213283917],[],[307,222,95],["D",1780267335950],[],[307,222,131],["D",1780213275215],[366,367,368,369,370,371,372,373,374],[307,222],"0fc603ae-5cc4-11f1-b9e7-1607ee4eb77e",["D",1780213257290],[365,375,376,377,378,379,380],[307],["D",1780184756415],["D",1789510270483],{"_11":12,"_277":86},{"_11":12,"_273":-5,"_85":86,"_31":84,"_274":275,"_276":30},{"_55":264,"_13":16,"_49":52,"_265":225,"_266":-5,"_267":-5,"_268":-5,"_269":-5,"_270":-5,"_271":14,"_272":12},"ctx",{"_68":-5,"_296":594,"_595":596,"_597":598,"_599":30,"_600":30,"_601":30,"_602":24,"_603":-5,"_604":-7,"_605":-7,"_606":26,"_607":30,"_608":30,"_609":-5,"_610":30,"_611":30,"_612":30,"_613":-5},"ENV",{"_565":566,"_567":568,"_569":16,"_570":571,"_572":573,"_574":575,"_576":577,"_578":579,"_580":581,"_582":583,"_584":585,"_586":587,"_588":589,"_590":591,"_592":593},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","fdb67791413f4386b4dbf18f354029a617f6160f","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · components