nou-cli 0.5.1 → 0.5.3

package/dist/src/conversations/external.js

@@ -0,0 +1,165 @@
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync } from "fs";
+import os from "os";
+import path from "path";
+/** Files looked at per tool: the newest ones. */
+const SCAN = 300;
+const claudeDir = (home) => process.env.CLAUDE_CONFIG_DIR ?? path.join(home, ".claude");
+const codexDir = (home) => process.env.CODEX_HOME ?? path.join(home, ".codex");
+function jsonLines(file, limit = Infinity) {
+    const out = [];
+    let text;
+    try {
+        text = readFileSync(file, "utf-8");
+    }
+    catch {
+        return out;
+    }
+    for (const line of text.split("\n")) {
+        if (out.length >= limit)
+            break;
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // a line being written
+        }
+    }
+    return out;
+}
+/** The start of a file, for the line that says which folder a Codex session ran in. */
+function head(file, bytes = 8192) {
+    const fd = openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(bytes);
+        return buf.subarray(0, readSync(fd, buf, 0, bytes, 0)).toString("utf-8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Plain text from a message's content (a string, or parts with text). */
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.filter((p) => typeof p?.text === "string" && /^(text|input_text|output_text)$/.test(p.type ?? "text")).map((p) => p.text).join("\n");
+}
+/** What the tools add on their own (context blocks, command echoes): not something you typed. */
+const injected = (text) => /^\s*<(environment_context|user_instructions|command-|local-command|system-reminder)/.test(text) || text.startsWith("Caveat:");
+const titleOf = (text) => text.replace(/\s+/g, " ").trim().slice(0, 80);
+/** Claude Code's sessions for this folder. */
+function claudeSessions(home, cwd) {
+    const dir = path.join(claudeDir(home), "projects", cwd.replace(/[^A-Za-z0-9]/g, "-"));
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path.join(dir, f));
+    const out = [];
+    for (const file of newest(files)) {
+        const said = claudeEntries(file);
+        const first = said.find((e) => e.kind === "user");
+        if (!first)
+            continue;
+        out.push({ id: path.basename(file, ".jsonl"), engine: "claude-code", title: titleOf(first.text), updated: statSync(file).mtimeMs, messages: said.filter((e) => e.kind === "user").length, file });
+    }
+    return out;
+}
+function claudeEntries(file) {
+    const out = [];
+    for (const line of jsonLines(file)) {
+        if (line.isSidechain || line.isMeta)
+            continue;
+        if (line.type === "user" && line.message?.role === "user") {
+            const text = textOf(line.message.content);
+            if (text.trim() && !injected(text))
+                out.push({ kind: "user", text: text.trim() });
+        }
+        else if (line.type === "assistant") {
+            const text = textOf(line.message?.content);
+            if (text.trim())
+                out.push({ kind: "assistant", text: text.trim() });
+        }
+    }
+    return out;
+}
+/** Codex's sessions for this folder (it keeps them all in one tree, by date). */
+function codexSessions(home, cwd) {
+    const root = path.join(codexDir(home), "sessions");
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    const walk = (dir, depth) => {
+        for (const name of readdirSync(dir).sort().reverse()) {
+            if (files.length >= SCAN)
+                return;
+            const full = path.join(dir, name);
+            if (depth < 3)
+                walk(full, depth + 1);
+            else if (name.startsWith("rollout-") && name.endsWith(".jsonl"))
+                files.push(full);
+        }
+    };
+    try {
+        walk(root, 0);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const file of files) {
+        let meta;
+        try {
+            meta = JSON.parse(head(file).split("\n")[0]);
+        }
+        catch {
+            continue;
+        }
+        const payload = meta?.type === "session_meta" ? meta.payload : null;
+        if (!payload?.id || path.resolve(payload.cwd ?? "") !== path.resolve(cwd))
+            continue;
+        const said = codexEntries(file);
+        const first = said.find((e) => e.kind === "user");
+        if (!first)
+            continue;
+        out.push({ id: payload.id, engine: "codex", title: titleOf(first.text), updated: statSync(file).mtimeMs, messages: said.filter((e) => e.kind === "user").length, file });
+    }
+    return out;
+}
+function codexEntries(file) {
+    const out = [];
+    for (const line of jsonLines(file)) {
+        const p = line.type === "response_item" ? line.payload : null;
+        if (p?.type !== "message")
+            continue;
+        const text = textOf(p.content).trim();
+        if (!text || injected(text))
+            continue;
+        if (p.role === "user")
+            out.push({ kind: "user", text });
+        else if (p.role === "assistant")
+            out.push({ kind: "assistant", text });
+    }
+    return out;
+}
+function newest(files) {
+    return files.map((f) => ({ f, t: statSync(f).mtimeMs })).sort((a, b) => b.t - a.t).slice(0, SCAN).map((x) => x.f);
+}
+/** Claude Code's and Codex's own sessions in this folder, latest first. */
+export function externalSessions(home = os.homedir(), cwd = process.cwd()) {
+    const out = [];
+    for (const read of [claudeSessions, codexSessions]) {
+        try {
+            out.push(...read(home, cwd));
+        }
+        catch {
+            // a tool's files we can't read: skip them
+        }
+    }
+    return out.sort((a, b) => b.updated - a.updated);
+}
+/** The chat of an external session, to show when it's resumed. */
+export function externalEntries(session) {
+    return session.engine === "claude-code" ? claudeEntries(session.file) : codexEntries(session.file);
+}

package/dist/src/conversations/index.js

@@ -0,0 +1,71 @@
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+import { NOU_HOME } from "../config/index.js";
+/** Kept per project: the oldest go once there are more. */
+const KEEP = 50;
+/** Chat entries saved per conversation (the latest ones). */
+const MAX_ENTRIES = 500;
+function folder(cwd = process.cwd()) {
+    const name = path.basename(cwd).replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 40);
+    return path.join(NOU_HOME, "conversations", `${name}-${createHash("sha1").update(cwd).digest("hex").slice(0, 10)}`);
+}
+export function saveConversation(conversation) {
+    const dir = folder();
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const entries = conversation.entries.slice(-MAX_ENTRIES);
+        writeFileSync(path.join(dir, `${conversation.id}.json`), JSON.stringify({ ...conversation, entries }), { mode: 0o600 });
+        const old = listConversations().slice(KEEP);
+        for (const c of old)
+            unlinkSync(path.join(dir, `${c.id}.json`));
+    }
+    catch {
+        // Saving is a convenience: a read-only home shouldn't break the chat.
+    }
+}
+/** This project's conversations, latest first. */
+export function listConversations() {
+    const dir = folder();
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const file of readdirSync(dir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const c = JSON.parse(readFileSync(path.join(dir, file), "utf-8"));
+            const state = c.state;
+            const ref = state?.claudeSession ?? state?.codexThread;
+            out.push({ id: c.id, title: c.title, updated: c.updated, engine: c.engine, messages: c.entries.filter((e) => e.kind === "user").length, ...(typeof ref === "string" ? { ref } : {}) });
+        }
+        catch {
+            // a damaged file is skipped
+        }
+    }
+    return out.sort((a, b) => b.updated - a.updated);
+}
+export function loadConversation(id) {
+    if (!/^[A-Za-z0-9_-]+$/.test(id))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path.join(folder(), `${id}.json`), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** "5m ago", "yesterday"... */
+export function ago(time, now = Date.now()) {
+    const s = Math.max(0, Math.round((now - time) / 1000));
+    if (s < 60)
+        return "just now";
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ago`;
+    if (s < 86_400)
+        return `${Math.floor(s / 3600)}h ago`;
+    if (s < 172_800)
+        return "yesterday";
+    return `${Math.floor(s / 86_400)}d ago`;
+}

package/dist/src/engines/claude.js

@@ -50,6 +50,16 @@ export class ClaudeCodeEngine extends ExternalEngine {
     resetConversation() {
         this.claudeSession = undefined;
     }
+    snapshot() {
+        return this.claudeSession ? { claudeSession: this.claudeSession } : undefined;
+    }
+    /** Claude Code keeps its sessions on disk, so a saved one resumes in a later run too. */
+    restore(state) {
+        if (typeof state?.claudeSession !== "string")
+            return false;
+        this.claudeSession = state.claudeSession;
+        return true;
+    }
     /** Claude Code can resume its session with another model, so the conversation carries over. */
     setModel(choice) {
         this.choice = choice;

package/dist/src/engines/codex.js

@@ -1,11 +1,14 @@
 import { execFileSync } from "child_process";
 import { statSync } from "fs";
+import { transientMessage } from "../agent/index.js";
 import { listAllFiles } from "../ui/QuickOpen.js";
 import { ExternalEngine } from "./external.js";
 import { loadPackage } from "./index.js";
 const EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
 const MAX_FILES = 5000;
 const MAX_BYTES = 512 * 1024;
+/** Times a turn that failed for a passing reason (a dropped stream, a failing server) is picked up again. */
+const RESUMES = 5;
 /** Project files small enough to keep a copy of (git's list when there is one, so ignored files are skipped). */
 function projectFiles() {
     let files;
@@ -42,34 +45,82 @@ export class CodexEngine extends ExternalEngine {
     id = "codex";
     thread = null;
     introduced = false;
+    /** A saved thread to pick back up (/resume): Codex keeps its threads on disk. */
+    resumeId;
     constructor(choice, hooks) {
         super(choice, hooks, "Codex");
     }
     resetConversation() {
         this.thread = null;
         this.introduced = false;
+        this.resumeId = undefined;
+    }
+    snapshot() {
+        const id = this.thread?.id ?? this.resumeId;
+        return id ? { codexThread: id } : undefined;
+    }
+    restore(state) {
+        if (typeof state?.codexThread !== "string")
+            return false;
+        this.thread = null;
+        this.resumeId = state.codexThread;
+        this.introduced = true; // it already has the project context
+        return true;
     }
     async run(prompt, signal) {
         const { Codex } = await loadPackage("@openai/codex-sdk");
         // Codex uses its own login (`codex login`); an OpenAI key from Nou's setup works too.
         const apiKey = process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY;
-        this.thread ??= new Codex(apiKey ? { apiKey } : {}).startThread({
+        const options = {
             workingDirectory: process.cwd(),
             skipGitRepoCheck: true,
             sandboxMode: "workspace-write",
+            // Its sandbox blocks the network by default, so npm/pip installs and tests that fetch fail ("can't
+            // resolve registry.npmjs.org"); Nou's other engines can reach it, so Codex can too.
+            networkAccessEnabled: true,
             approvalPolicy: "never",
             ...(this.choice.provider.id === "openai" ? { model: this.choice.model } : {}),
             ...(this.effort && EFFORTS.has(this.effort) ? { modelReasoningEffort: this.effort } : {}),
-        });
+        };
+        const codex = new Codex(apiKey ? { apiKey } : {});
+        this.thread ??= this.resumeId ? codex.resumeThread(this.resumeId, options) : codex.startThread(options);
         // Codex has no system prompt option; Nou's project context goes with the first message.
         const input = !this.introduced && this.extras.length ? `${this.extras.join("\n\n")}\n\n${prompt}` : prompt;
         this.introduced = true;
         this.tracker.remember(projectFiles());
+        // Codex retries a dropped stream itself ("Reconnecting... 2/5"); when it gives up, Nou picks the turn up
+        // again on the same thread, waiting longer each time, before calling it failed.
+        for (let attempt = 0;; attempt++) {
+            const failure = await this.runTurn(attempt ? "The connection dropped before you finished. Carry on where you left off." : input, signal);
+            if (!failure)
+                return;
+            if (attempt >= RESUMES || !transientMessage(failure))
+                throw new Error(explain(failure));
+            const wait = Math.min(30_000, 2000 * 2 ** attempt);
+            this.hooks.onStream("");
+            this.hooks.onBusy(`Codex: ${failure.split("\n")[0].slice(0, 70)}. Retrying in ${wait / 1000}s (${attempt + 1}/${RESUMES})...`);
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, wait);
+                signal.addEventListener("abort", () => (clearTimeout(timer), resolve()), { once: true });
+            });
+            if (signal.aborted)
+                throw new Error("aborted");
+        }
+    }
+    /** Runs one Codex turn; returns why it failed, if it did. */
+    async runTurn(input, signal) {
         let failure;
         try {
             const { events } = await this.thread.runStreamed(input, { signal });
-            for await (const event of events)
+            for await (const event of events) {
+                if (event.type === "turn.completed") {
+                    // Its turn is over (it may have just asked you something): done now, rather than waiting for the
+                    // codex process to wind down, which kept "Codex is working..." up under its question.
+                    failure = undefined; // and it recovered from anything that went wrong on the way
+                    break;
+                }
                 failure = (await this.handle(event)) ?? failure;
+            }
         }
         catch (error) {
             // The codex process exiting with an error ends the stream; its first line says why.
@@ -79,8 +130,7 @@ export class CodexEngine extends ExternalEngine {
         }
         if (signal.aborted)
             throw new Error("aborted");
-        if (failure)
-            throw new Error(explain(failure));
+        return failure;
     }
     /** Shows one Codex event; returns the error message if the turn failed. */
     async handle(event) {
@@ -124,6 +174,11 @@ export class CodexEngine extends ExternalEngine {
             return event.error.message;
         }
         else if (event.type === "error") {
+            // "Reconnecting... 1/5 (stream disconnected ...)": Codex is retrying, so it's progress, not the end.
+            if (/^Reconnecting\b/i.test(event.message)) {
+                this.hooks.onBusy(`Codex: ${event.message.split("\n")[0].slice(0, 100)}`);
+                return undefined;
+            }
             return event.message;
         }
         return undefined;

package/dist/src/games/index.js

@@ -0,0 +1,217 @@
+/**
+ * Little games for the Games panel, drawn with text. Each one is plain state and three functions, so the
+ * panel can run any of them and the tests can play them without a terminal.
+ */
+/** A small seeded random number generator, so games can be replayed in tests. */
+function rng(seed) {
+    let s = seed >>> 0 || 1;
+    return () => {
+        s ^= s << 13;
+        s ^= s >>> 17;
+        s ^= s << 5;
+        return (s >>> 0) / 4294967296;
+    };
+}
+const blank = (w, h) => Array.from({ length: h }, () => Array(w).fill(" "));
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const PADDLE = 3;
+const PONG_WIN = 7;
+function serve(s, toward) {
+    const vy = (s.random() - 0.5) * 1.2;
+    return { ...s, bx: s.w / 2, by: s.h / 2, vx: toward * 0.9, vy: Math.abs(vy) < 0.2 ? 0.4 : vy };
+}
+export const pong = {
+    id: "pong",
+    title: "Pong",
+    blurb: "The classic: you on the left, the computer on the right. First to 7.",
+    controls: "↑↓ or w/s move",
+    tickMs: 50,
+    colors: { "█": "#61afef", "●": "#e5c07b", "┊": "#5c6370" },
+    create(w, h, seed = Date.now()) {
+        const s = { w, h, you: Math.floor((h - PADDLE) / 2), them: Math.floor((h - PADDLE) / 2), bx: 0, by: 0, vx: 0, vy: 0, scores: [0, 0], random: rng(seed) };
+        return serve(s, -1);
+    },
+    tick(s, inputs) {
+        if (s.scores[0] >= PONG_WIN || s.scores[1] >= PONG_WIN)
+            return s;
+        let you = s.you;
+        for (const i of inputs)
+            you += i === "up" ? -1 : i === "down" ? 1 : 0;
+        you = clamp(you, 0, s.h - PADDLE);
+        // The computer follows the ball, a bit slower than it moves, so it can be beaten.
+        const target = s.by - PADDLE / 2;
+        const them = clamp(s.them + clamp(target - s.them, -0.55, 0.55), 0, s.h - PADDLE);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (by < 0)
+            [by, vy] = [-by, -vy];
+        if (by > s.h - 1)
+            [by, vy] = [2 * (s.h - 1) - by, -vy];
+        // Paddles at x=1 and x=w-2; where the ball hits the paddle sets its angle.
+        if (vx < 0 && bx <= 1.5 && bx >= 0.5 && by >= you - 0.5 && by <= you + PADDLE - 0.5) {
+            [bx, vx, vy] = [1.5, Math.min(1.4, -vx * 1.05), (by - (you + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        if (vx > 0 && bx >= s.w - 2.5 && bx <= s.w - 1.5 && by >= them - 0.5 && by <= them + PADDLE - 0.5) {
+            [bx, vx, vy] = [s.w - 2.5, -Math.min(1.4, vx * 1.05), (by - (them + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        const next = { ...s, you, them, bx, by, vx, vy };
+        if (bx < 0)
+            return serve({ ...next, scores: [s.scores[0], s.scores[1] + 1] }, -1);
+        if (bx > s.w - 1)
+            return serve({ ...next, scores: [s.scores[0] + 1, s.scores[1]] }, 1);
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        for (let y = 0; y < s.h; y += 2)
+            grid[y][Math.floor(s.w / 2)] = "┊";
+        for (let k = 0; k < PADDLE; k++) {
+            grid[s.you + k][1] = "█";
+            grid[Math.round(s.them) + k][s.w - 2] = "█";
+        }
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const [a, b] = s.scores;
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `you ${a} · ${b} computer   ↑↓ move`,
+            ...(a >= PONG_WIN ? { over: "You win! ✦" } : b >= PONG_WIN ? { over: "The computer wins." } : {}),
+        };
+    },
+};
+const DIRS = { up: { x: 0, y: -1 }, down: { x: 0, y: 1 }, left: { x: -1, y: 0 }, right: { x: 1, y: 0 } };
+const OPPOSITE = { up: "down", down: "up", left: "right", right: "left" };
+function placeFood(s) {
+    for (let tries = 0; tries < 500; tries++) {
+        const p = { x: Math.floor(s.random() * s.w), y: Math.floor(s.random() * s.h) };
+        if (!s.body.some((b) => b.x === p.x && b.y === p.y))
+            return p;
+    }
+    return { x: 0, y: 0 };
+}
+export const snake = {
+    id: "snake",
+    title: "Snake",
+    blurb: "Eat, grow, don't bite yourself or the walls.",
+    controls: "arrows or wasd steer",
+    tickMs: 110,
+    colors: { "█": "#98c379", "▓": "#7ec16e", "◆": "#e06c75" },
+    create(w, h, seed = Date.now()) {
+        const y = Math.floor(h / 2);
+        const s = { w, h, body: [{ x: 4, y }, { x: 3, y }, { x: 2, y }], dir: "right", food: { x: 0, y: 0 }, score: 0, dead: false, random: rng(seed) };
+        return { ...s, food: placeFood(s) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        let dir = s.dir;
+        // One turn per tick (the first that isn't straight back), so quick double taps don't fold it onto itself.
+        for (const i of inputs) {
+            if (i !== OPPOSITE[dir] && i !== dir) {
+                dir = i;
+                break;
+            }
+        }
+        const head = { x: s.body[0].x + DIRS[dir].x, y: s.body[0].y + DIRS[dir].y };
+        const eats = head.x === s.food.x && head.y === s.food.y;
+        const rest = eats ? s.body : s.body.slice(0, -1);
+        const dead = head.x < 0 || head.y < 0 || head.x >= s.w || head.y >= s.h || rest.some((b) => b.x === head.x && b.y === head.y);
+        if (dead)
+            return { ...s, dir, dead: true };
+        const next = { ...s, dir, body: [head, ...rest], score: s.score + (eats ? 1 : 0) };
+        return eats ? { ...next, food: placeFood(next) } : next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        grid[s.food.y][s.food.x] = "◆";
+        s.body.forEach((b, i) => {
+            if (grid[b.y]?.[b.x] !== undefined)
+                grid[b.y][b.x] = i === 0 ? "█" : "▓";
+        });
+        return { lines: grid.map((r) => r.join("")), status: `length ${s.body.length} · score ${s.score}`, ...(s.dead ? { over: `Game over: ${s.score} eaten.` } : {}) };
+    },
+};
+const PAD = 7;
+const BRICK_ROWS = 4;
+function launch(s) {
+    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * 0.6, vy: -0.6 };
+}
+export const breakout = {
+    id: "breakout",
+    title: "Breakout",
+    blurb: "Knock out every brick with the ball. Three lives.",
+    controls: "←→ or a/d move",
+    tickMs: 45,
+    colors: { "▀": "#e06c75", "▄": "#d19a66", "▬": "#61afef", "●": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        const s = {
+            w, h, paddle: Math.floor((w - PAD) / 2), bx: 0, by: 0, vx: 0, vy: 0,
+            bricks: Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true)), lives: 3, score: 0, random: rng(seed),
+        };
+        return launch(s);
+    },
+    tick(s, inputs) {
+        if (s.lives <= 0 || s.bricks.every((r) => r.every((b) => !b)))
+            return s;
+        let paddle = s.paddle;
+        for (const i of inputs)
+            paddle += i === "left" ? -2 : i === "right" ? 2 : 0;
+        paddle = clamp(paddle, 0, s.w - PAD);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (bx < 0 || bx > s.w - 1)
+            [bx, vx] = [clamp(bx, 0, s.w - 1), -vx];
+        if (by < 0)
+            [by, vy] = [0, -vy];
+        // Bricks are three columns wide, on rows 1.. so there's a gap at the top.
+        const bricks = s.bricks.map((r) => [...r]);
+        let score = s.score;
+        const row = Math.floor(by) - 1;
+        const col = Math.floor(bx / 3);
+        if (row >= 0 && row < BRICK_ROWS && bricks[row]?.[col]) {
+            bricks[row][col] = false;
+            score += (BRICK_ROWS - row) * 10;
+            vy = -vy;
+        }
+        // The paddle sits on the last row; where the ball lands on it sets the angle.
+        if (vy > 0 && by >= s.h - 2 && by < s.h - 1 && bx >= paddle - 0.5 && bx <= paddle + PAD - 0.5) {
+            vy = -Math.abs(vy);
+            vx = clamp((bx - (paddle + PAD / 2 - 0.5)) * 0.25, -1, 1) || 0.3;
+            by = s.h - 2;
+        }
+        const next = { ...s, paddle, bx, by, vx, vy, bricks, score };
+        if (by > s.h - 1) {
+            const lives = s.lives - 1;
+            return lives > 0 ? launch({ ...next, lives }) : { ...next, lives };
+        }
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        s.bricks.forEach((r, y) => r.forEach((alive, x) => {
+            if (alive)
+                for (let k = 0; k < 3; k++)
+                    if (x * 3 + k < s.w - 0)
+                        grid[y + 1][x * 3 + k] = y % 2 ? "▄" : "▀";
+        }));
+        for (let k = 0; k < PAD; k++)
+            grid[s.h - 1][s.paddle + k] = "▬";
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (s.lives > 0 && grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const cleared = s.bricks.every((r) => r.every((b) => !b));
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
+            ...(cleared ? { over: `Cleared! ${s.score} points ✦` } : s.lives <= 0 ? { over: `Game over: ${s.score} points.` } : {}),
+        };
+    },
+};
+/** Every game Nou has, in the order settings lists them. */
+export const GAMES = [pong, snake, breakout];
+export const gameById = (id) => GAMES.find((g) => g.id === id);