novac 2.3.0 → 2.4.0

package/kits/kitarcade/kitdef.js

@@ -0,0 +1,2709 @@
+'use strict';
+
+/**
+ * kitarcade — Terminal games kit
+ *
+ * Every game object shares this API:
+ *   .start()          restart / begin
+ *   .input(key)       key names: 'up' 'down' 'left' 'right' 'space' 'enter'
+ *                     'escape' 'tab'  and any single char ('a'–'z', '0'–'9')
+ *   .tick(dt = 16)    advance by dt ms; drive at your preferred fps
+ *   .frame()          → ANSI string ready to write to terminal
+ *   .state            → 'idle' | 'playing' | 'paused' | 'gameover' | 'won'
+ *   .score            → number
+ *   .on(ev, fn)       events: 'start' 'gameover' 'win' 'score'
+ *   .off(ev, fn)
+ *
+ * Quick-start:
+ *   const { kitdef } = require('./kitarcade');
+ *   const game = kitdef.Snake();
+ *   game.start();
+ *   process.stdin.setRawMode(true);
+ *   process.stdin.on('data', buf => {
+ *     const k = buf.toString();
+ *     if      (k === '\x1b[A') game.input('up');
+ *     else if (k === '\x1b[B') game.input('down');
+ *     else if (k === '\x1b[C') game.input('right');
+ *     else if (k === '\x1b[D') game.input('left');
+ *     else if (k === ' ')      game.input('space');
+ *     else if (k === '\r')     game.input('enter');
+ *     else if (k === '\x1b')   game.input('escape');
+ *     else                     game.input(k.toLowerCase());
+ *   });
+ *   setInterval(() => {
+ *     process.stdout.write('\x1b[H\x1b[2J' + game.frame());
+ *     if (game.state === 'gameover') process.exit();
+ *   }, 50);
+ * 
+ *   // or simply:
+ *   kitdef.RunGame(kitdef.Snake());
+ * 
+ *   the RunGame helper sets up the stdin and tick loop for you, and handles clean exit on gameover.
+ *   the manual setup is there if you want more control, e.g. for a custom tick rate, or to run multiple games at once, or even custom input handling.
+ */
+
+// ─── SHARED UTILITIES ────────────────────────────────────────────────────────
+
+const FC = {
+  blk:30,red:31,grn:32,yel:33,blu:34,mag:35,cyn:36,wht:37,
+  BLK:90,RED:91,GRN:92,YEL:93,BLU:94,MAG:95,CYN:96,WHT:97,
+};
+const BC = {
+  blk:40,red:41,grn:42,yel:43,blu:44,mag:45,cyn:46,wht:47,
+  BLK:100,RED:101,GRN:102,YEL:103,BLU:104,MAG:105,CYN:106,WHT:107,
+};
+const RST = '\x1b[0m';
+const BLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+
+function makeCanvas(W, H) {
+  const ch = Array.from({length:H}, () => new Array(W).fill(' '));
+  const fg = Array.from({length:H}, () => new Array(W).fill(FC.wht));
+  const bg = Array.from({length:H}, () => new Array(W).fill(BC.blk));
+  const cv = {
+    W, H,
+    clear(c=' ', f=FC.wht, b=BC.blk) {
+      for (let y=0;y<H;y++) for (let x=0;x<W;x++) { ch[y][x]=c;fg[y][x]=f;bg[y][x]=b; }
+    },
+    set(x, y, c, f=FC.wht, b=BC.blk) {
+      if (x<0||x>=W||y<0||y>=H) return;
+      ch[y][x] = (String(c)[0])||' '; fg[y][x]=f; bg[y][x]=b;
+    },
+    put(x, y, s, f=FC.wht, b=BC.blk) {
+      for (let i=0;i<s.length;i++) cv.set(x+i, y, s[i], f, b);
+    },
+    fill(x, y, w, h, c, f=FC.wht, b=BC.blk) {
+      for (let dy=0;dy<h;dy++) for (let dx=0;dx<w;dx++) cv.set(x+dx,y+dy,c,f,b);
+    },
+    box(x, y, w, h, f=FC.wht, b=BC.blk) {
+      cv.put(x, y, '┌'+'─'.repeat(w-2)+'┐', f, b);
+      for (let dy=1;dy<h-1;dy++) { cv.set(x,y+dy,'│',f,b); cv.set(x+w-1,y+dy,'│',f,b); }
+      cv.put(x, y+h-1, '└'+'─'.repeat(w-2)+'┘', f, b);
+    },
+    render() {
+      const lines = [];
+      for (let y=0;y<H;y++) {
+        let row='', cf=-1, cb=-1;
+        for (let x=0;x<W;x++) {
+          const f=fg[y][x], b=bg[y][x];
+          if (f!==cf||b!==cb) { row+=`\x1b[${f};${b}m`; cf=f; cb=b; }
+          row += ch[y][x];
+        }
+        lines.push(row+RST);
+      }
+      return lines.join('\n');
+    },
+  };
+  return cv;
+}
+
+function makeEmitter() {
+  const L = new Map();
+  return {
+    on(ev, fn)  { if(!L.has(ev)) L.set(ev,[]); L.get(ev).push(fn); },
+    off(ev, fn) { if(L.has(ev)) L.set(ev, L.get(ev).filter(f=>f!==fn)); },
+    emit(ev, ...a) { (L.get(ev)??[]).forEach(fn=>fn(...a)); },
+  };
+}
+
+const rng   = (n) => Math.random() * n | 0;
+const clamp = (x, lo, hi) => Math.max(lo, Math.min(hi, x));
+function shuffle(a) {
+  const b = [...a];
+  for (let i=b.length-1;i>0;i--) { const j=rng(i+1); [b[i],b[j]]=[b[j],b[i]]; }
+  return b;
+}
+
+// ─── WORD BANKS ───────────────────────────────────────────────────────────────
+
+const WORDLE_WORDS = [
+  'about','above','abuse','actor','acute','admit','adopt','adult','after','again',
+  'agent','agree','ahead','alarm','album','alert','alike','alive','alley','allow',
+  'alone','along','angel','anger','angle','angry','ankle','apply','arena','argue',
+  'arise','armor','arson','array','aside','asset','atlas','attic','audio','avoid',
+  'award','aware','awful','bacon','badge','baker','basic','batch','beard','beast',
+  'bench','birth','black','blade','blank','blast','blaze','bleed','bless','blend',
+  'blind','blood','bloom','blues','board','bonus','boost','bound','boxer','brain',
+  'brand','brave','bread','break','breed','bride','brief','bring','broad','broke',
+  'brush','buddy','build','built','bunch','burst','buyer','cabin','cable','carry',
+  'catch','cause','chain','chaos','charm','check','chest','chose','chunk','civil',
+  'claim','class','clean','clear','click','cliff','climb','clock','clone','close',
+  'cloud','coach','coast','coral','could','count','cover','crack','craft','crane',
+  'crazy','crime','crisp','cross','crowd','crown','crush','cubic','curve','cycle',
+  'daily','dance','death','debut','delay','delta','dense','depot','derby','devil',
+  'dirty','diver','dizzy','dodge','doing','doubt','dough','douse','draft','drain',
+  'drama','dream','dress','drift','drink','drive','drone','drove','dwarf','dying',
+  'eagle','early','earth','eight','elite','empty','enemy','enjoy','enter','entry',
+  'equal','error','event','every','exact','exist','extra','fable','fairy','faith',
+  'false','fancy','fatal','fault','feast','fence','field','fifth','fifty','fight',
+];
+
+const HANGMAN_WORDS = [
+  'elephant','giraffe','penguin','dolphin','universe','mountain','keyboard','chocolate',
+  'adventure','symphony','democracy','laboratory','philosophy','electricity','caterpillar',
+  'metamorphosis','catastrophe','bibliophile','serendipity','extraordinary','constellation',
+  'hippopotamus','kaleidoscope','neighbourhood','thunderstorm','championship','algorithm',
+  'certificate','competition','deliberately','entertainment','establishment','infrastructure',
+  'investigation','knowledgeable','magnificent','opportunities','pharmaceutical','quarterback',
+  'refrigerator','subscription','transformation','uncomfortable','vulnerability','xylophone',
+  'accomplished','battlefield','comfortable','development','furthermore','government',
+  'helicopter','immediately','journalism','kindergarten','linguistics','masterpiece',
+  'notification','observatory','perspective','quadrilateral','refreshment','successfully',
+];
+
+const TYPING_PHRASES = [
+  'the quick brown fox jumps over the lazy dog and keeps running through the forest',
+  'programming is the art of telling another human what one wants the computer to do',
+  'any sufficiently advanced technology is indistinguishable from magic according to clarke',
+  'in theory there is no difference between theory and practice but in practice there is',
+  'first solve the problem then write the code otherwise you are just writing bad code faster',
+  'the best error message is the one that never shows up because you prevented the bug',
+  'debugging is like being the detective in a crime movie where you are also the murderer',
+  'code is like humor when you have to explain it it is not that good at all really',
+];
+
+// ─── SUDOKU PUZZLES ───────────────────────────────────────────────────────────
+
+const SUDOKU_PUZZLES = [
+  '53..7....6..195....98....6.8...6...34..8.3..17...2...6.6....28....419..5....8..79',
+  '.......1.4.........2...........5.4.7..8...3....1.9....3..4..2...5.1........8.6...',
+  '..9748...7.........2.1.9.....7...24..64.1.59..98...3.....8.3.2.........6...2759..',
+  '1....7.9..3..2...8..96..5....53..9...1..8...26....4...3......1..4......7..7...3..',
+  '.3.5..8.5.5.9...2...7.8.1.7.4...5.......3..1...7...6.....5..........8.....6.....',
+];
+
+// ─── GAME: SNAKE ─────────────────────────────────────────────────────────────
+
+function makeSnake(opts = {}) {
+  const GW = opts.width  ?? 30;
+  const GH = opts.height ?? 20;
+  const em = makeEmitter();
+  let snake, dir, nextDir, food, score, state, elapsed, speed;
+
+  function spawnFood() {
+    let fx, fy;
+    do { fx=rng(GW); fy=rng(GH); } while (snake.some(s=>s.x===fx&&s.y===fy));
+    food = {x:fx, y:fy};
+  }
+
+  function start() {
+    snake = [{x:5,y:GH>>1},{x:4,y:GH>>1},{x:3,y:GH>>1}];
+    dir = {dx:1,dy:0}; nextDir = {dx:1,dy:0};
+    score = 0; elapsed = 0; speed = 150; state = 'playing';
+    spawnFood(); em.emit('start');
+  }
+
+  function input(key) {
+    if (state === 'gameover' && key === 'enter') { start(); return; }
+    if (state !== 'playing') return;
+    const nd = { up:{dx:0,dy:-1}, down:{dx:0,dy:1}, left:{dx:-1,dy:0}, right:{dx:1,dy:0} }[key];
+    if (nd && !(nd.dx===-dir.dx && nd.dy===-dir.dy)) nextDir = nd;
+  }
+
+  function step() {
+    dir = nextDir;
+    const head = snake[0];
+    const nx = head.x + dir.dx, ny = head.y + dir.dy;
+    if (nx<0||nx>=GW||ny<0||ny>=GH||snake.some(s=>s.x===nx&&s.y===ny)) {
+      state = 'gameover'; em.emit('gameover', score); return;
+    }
+    snake.unshift({x:nx,y:ny});
+    if (nx===food.x && ny===food.y) {
+      score += 10; speed = Math.max(60, speed - 2);
+      em.emit('score', score); spawnFood();
+    } else { snake.pop(); }
+  }
+
+  function tick(dt=16) {
+    if (state !== 'playing') return;
+    elapsed += dt;
+    while (elapsed >= speed) { elapsed -= speed; step(); if (state!=='playing') break; }
+  }
+
+  function frame() {
+    const cv = makeCanvas(GW*2+2, GH+3);
+    cv.clear(' ', FC.wht, BC.blk);
+    // title
+    cv.put(0, 0, ` SNAKE   Score: ${score}   Length: ${snake.length}   [WASD/Arrows]`, FC.YEL, BC.blk);
+    // border
+    cv.box(0, 1, GW*2+2, GH+2, FC.wht, BC.blk);
+    // food
+    cv.put(food.x*2+1, food.y+2, '()', FC.RED, BC.blk);
+    // snake
+    for (let i=snake.length-1;i>=0;i--) {
+      const s=snake[i];
+      const isHead = i===0;
+      const col = isHead ? FC.GRN : (i%2===0 ? FC.grn : FC.GRN);
+      cv.put(s.x*2+1, s.y+2, isHead?'◉◉':'██', col, BC.blk);
+    }
+    if (state==='gameover') {
+      const msg='  GAME OVER  Press ENTER  ';
+      cv.put((GW*2+2-msg.length)>>1, (GH>>1)+2, msg, FC.WHT, BC.red);
+    }
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: TETRIS ─────────────────────────────────────────────────────────────
+
+const PIECES = {
+  I:{col:FC.CYN,shapes:[[[0,0,0,0],[1,1,1,1],[0,0,0,0],[0,0,0,0]],[[0,0,1,0],[0,0,1,0],[0,0,1,0],[0,0,1,0]],[[0,0,0,0],[0,0,0,0],[1,1,1,1],[0,0,0,0]],[[0,1,0,0],[0,1,0,0],[0,1,0,0],[0,1,0,0]]]},
+  O:{col:FC.YEL,shapes:[[[1,1],[1,1]],[[1,1],[1,1]],[[1,1],[1,1]],[[1,1],[1,1]]]},
+  T:{col:FC.MAG,shapes:[[[0,1,0],[1,1,1],[0,0,0]],[[0,1,0],[0,1,1],[0,1,0]],[[0,0,0],[1,1,1],[0,1,0]],[[0,1,0],[1,1,0],[0,1,0]]]},
+  S:{col:FC.GRN,shapes:[[[0,1,1],[1,1,0],[0,0,0]],[[0,1,0],[0,1,1],[0,0,1]],[[0,0,0],[0,1,1],[1,1,0]],[[1,0,0],[1,1,0],[0,1,0]]]},
+  Z:{col:FC.RED,shapes:[[[1,1,0],[0,1,1],[0,0,0]],[[0,0,1],[0,1,1],[0,1,0]],[[0,0,0],[1,1,0],[0,1,1]],[[0,1,0],[1,1,0],[1,0,0]]]},
+  J:{col:FC.BLU,shapes:[[[1,0,0],[1,1,1],[0,0,0]],[[0,1,1],[0,1,0],[0,1,0]],[[0,0,0],[1,1,1],[0,0,1]],[[0,1,0],[0,1,0],[1,1,0]]]},
+  L:{col:FC.yel,shapes:[[[0,0,1],[1,1,1],[0,0,0]],[[0,1,0],[0,1,0],[0,1,1]],[[0,0,0],[1,1,1],[1,0,0]],[[1,1,0],[0,1,0],[0,1,0]]]},
+};
+const PIECE_KEYS = Object.keys(PIECES);
+const SCORE_TABLE = [0,100,300,500,800];
+
+function makeTetris(opts = {}) {
+  const BW=10, BH=20;
+  const em = makeEmitter();
+  let board, colors, current, rotation, px, py, hold, holdUsed, bag, next;
+  let score, level, lines, state, elapsed, gravity;
+
+  function newBag() { return shuffle(PIECE_KEYS); }
+  function nextPiece() {
+    if (!bag.length) bag = newBag();
+    return bag.shift();
+  }
+
+  function spawn(key) {
+    current = key; rotation = 0;
+    const shape = PIECES[key].shapes[0];
+    px = (BW - shape[0].length) >> 1; py = 0;
+    if (collides(px, py, rotation)) { state='gameover'; em.emit('gameover',score); }
+  }
+
+  function collides(tx, ty, rot) {
+    const shape = PIECES[current].shapes[rot];
+    for (let r=0;r<shape.length;r++)
+      for (let c=0;c<shape[r].length;c++)
+        if (shape[r][c]) {
+          const nx=tx+c, ny=ty+r;
+          if (nx<0||nx>=BW||ny>=BH) return true;
+          if (ny>=0 && board[ny*BW+nx]) return true;
+        }
+    return false;
+  }
+
+  function lock() {
+    const shape = PIECES[current].shapes[rotation];
+    const col   = PIECES[current].col;
+    for (let r=0;r<shape.length;r++)
+      for (let c=0;c<shape[r].length;c++)
+        if (shape[r][c] && py+r>=0) {
+          board[(py+r)*BW+(px+c)] = 1;
+          colors[(py+r)*BW+(px+c)] = col;
+        }
+    // clear lines
+    let cleared = 0;
+    for (let r=BH-1;r>=0;r--) {
+      if ([...Array(BW)].every((_,c)=>board[r*BW+c])) {
+        board.splice(r*BW, BW);   colors.splice(r*BW, BW);
+        board.unshift(...new Array(BW).fill(0));
+        colors.unshift(...new Array(BW).fill(0));
+        cleared++; r++;
+      }
+    }
+    if (cleared) {
+      lines += cleared; score += SCORE_TABLE[cleared] * level;
+      level = Math.floor(lines/10)+1; gravity = Math.max(50, 1000-level*90);
+      em.emit('score', score);
+    }
+    holdUsed = false;
+    spawn(nextPiece());
+  }
+
+  function start() {
+    board   = new Array(BW*BH).fill(0);
+    colors  = new Array(BW*BH).fill(0);
+    bag     = newBag(); next = newBag(); hold = null; holdUsed = false;
+    score   = 0; level = 1; lines = 0; elapsed = 0; gravity = 1000; state = 'playing';
+    spawn(nextPiece()); em.emit('start');
+  }
+
+  function doHold() {
+    if (holdUsed) return;
+    holdUsed = true;
+    const prev = hold;
+    hold = current;
+    spawn(prev ?? nextPiece());
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter') { start(); return; }
+    if (state!=='playing') return;
+    if (key==='left'  && !collides(px-1,py,rotation)) px--;
+    if (key==='right' && !collides(px+1,py,rotation)) px++;
+    if (key==='down'  && !collides(px,py+1,rotation)) { py++; score+=1; }
+    if (key==='up'||key==='z') {
+      const nr=(rotation+1)%4;
+      if (!collides(px,py,nr)) rotation=nr;
+      else if (!collides(px-1,py,nr)) { px--; rotation=nr; }
+      else if (!collides(px+1,py,nr)) { px++; rotation=nr; }
+    }
+    if (key==='space') { // hard drop
+      while (!collides(px,py+1,rotation)) { py++; score+=2; }
+      lock();
+    }
+    if (key==='c'||key==='tab') doHold();
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    if (elapsed>=gravity) { elapsed=0; if (!collides(px,py+1,rotation)) py++; else lock(); }
+  }
+
+  function ghostY() {
+    let gy=py;
+    while (!collides(px,gy+1,rotation)) gy++;
+    return gy;
+  }
+
+  function frame() {
+    const SIDE=14; const CW=BW*2+2+SIDE+2;
+    const cv=makeCanvas(CW, BH+3); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,`${BLD} TETRIS ${RST} Lv:${level} Lines:${lines} Score:${score}  [←→↓ Move  ↑ Rotate  Space Hard-drop  C Hold]`,FC.YEL,BC.blk);
+    // board border
+    cv.box(0,1,BW*2+2,BH+2,FC.wht,BC.blk);
+    // board cells
+    for (let r=0;r<BH;r++) for (let c=0;c<BW;c++) {
+      if (board[r*BW+c]) cv.put(c*2+1,r+2,'██',colors[r*BW+c],BC.blk);
+    }
+    // ghost
+    const gy=ghostY();
+    const gs=PIECES[current].shapes[rotation];
+    for (let r=0;r<gs.length;r++) for (let c=0;c<gs[r].length;c++)
+      if (gs[r][c] && gy+r>=0) cv.put((px+c)*2+1,gy+r+2,'░░',FC.BLK,BC.blk);
+    // current piece
+    for (let r=0;r<gs.length;r++) for (let c=0;c<gs[r].length;c++)
+      if (gs[r][c] && py+r>=0) cv.put((px+c)*2+1,py+r+2,'██',PIECES[current].col,BC.blk);
+    // sidebar
+    const sx=BW*2+3;
+    cv.put(sx,2,'NEXT:',FC.CYN,BC.blk);
+    if (bag.length) {
+      const nk=bag[0], ns=PIECES[nk].shapes[0];
+      for (let r=0;r<ns.length;r++) for (let c=0;c<ns[r].length;c++)
+        if (ns[r][c]) cv.put(sx+c*2,3+r,'██',PIECES[nk].col,BC.blk);
+    }
+    cv.put(sx,8,`HOLD: ${hold??'---'}`,FC.CYN,BC.blk);
+    if (hold) {
+      const hs=PIECES[hold].shapes[0];
+      for (let r=0;r<hs.length;r++) for (let c=0;c<hs[r].length;c++)
+        if (hs[r][c]) cv.put(sx+c*2,9+r,'██',holdUsed?FC.BLK:PIECES[hold].col,BC.blk);
+    }
+    if (state==='gameover') cv.put(1,BH/2+2|0,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: DINO RUN ──────────────────────────────────────────────────────────
+
+function makeDinoRun(opts = {}) {
+  const W=80, H=9;
+  const GROUND=6, DINO_X=5;
+  const em=makeEmitter();
+  let dinoY, velY, onGround, obstacles, clouds, score, speed, elapsed, state, frame_n;
+
+  function start() {
+    dinoY=GROUND; velY=0; onGround=true;
+    obstacles=[]; clouds=[{x:60,y:1},{x:40,y:2},{x:20,y:1}];
+    score=0; speed=0.15; elapsed=0; frame_n=0; state='playing';
+    em.emit('start');
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter') { start(); return; }
+    if (state!=='playing') return;
+    if ((key==='space'||key==='up')&&onGround) { velY=-1.4; onGround=false; }
+    if ((key==='down')&&!onGround) velY+=0.5; // fast fall
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    if (elapsed<50) return; elapsed=0; frame_n++;
+
+    // physics
+    velY+=0.2; dinoY+=velY;
+    if (dinoY>=GROUND) { dinoY=GROUND; velY=0; onGround=true; }
+
+    // scroll
+    speed = Math.min(0.45, 0.15 + score*0.0003);
+    const dx = Math.ceil(speed*10);
+
+    // obstacles
+    for (const o of obstacles) o.x -= dx;
+    obstacles = obstacles.filter(o=>o.x>-3);
+    if (!obstacles.length || obstacles[obstacles.length-1].x < 60-rng(30)) {
+      const h = 1+rng(2);
+      obstacles.push({x:W+2, h, w:1+rng(2)});
+    }
+
+    // clouds
+    for (const c of clouds) c.x -= 1;
+    clouds = clouds.filter(c=>c.x>-5);
+    if (clouds.length<3) clouds.push({x:W+5, y:1+rng(3)});
+
+    // score
+    score++; em.emit('score', score);
+
+    // collision: dino occupies cols DINO_X..DINO_X+1, rows dinoY-1..dinoY
+    const dy0=Math.round(dinoY)-1, dy1=Math.round(dinoY);
+    for (const o of obstacles) {
+      const ox0=o.x, ox1=o.x+o.w-1;
+      const oy0=GROUND-o.h, oy1=GROUND;
+      if (ox0<=DINO_X+1 && ox1>=DINO_X && oy0<=dy1 && oy1>=dy0) {
+        state='gameover'; em.emit('gameover',score); return;
+      }
+    }
+  }
+
+  function frame() {
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` DINO RUN   Score: ${score}   Speed: x${speed.toFixed(2)}   SPACE/UP to jump  ENTER restart`,FC.YEL,BC.blk);
+    // clouds
+    for (const c of clouds) if (c.x>=0&&c.x<W) cv.put(c.x,c.y,'~~~',FC.BLK,BC.blk);
+    // ground
+    cv.put(0,GROUND+1,'─'.repeat(W),FC.wht,BC.blk);
+    cv.put(0,GROUND+2,'═'.repeat(W),FC.BLK,BC.blk);
+    // dino
+    const dy=Math.round(dinoY);
+    const blink = frame_n%4<2;
+    cv.put(DINO_X,dy-1, blink?'(Ö)':'(Ȯ)', FC.GRN,BC.blk);
+    cv.put(DINO_X,dy,   onGround?(frame_n%4<2?'/|\\':'|/\\'):'(_)', FC.GRN,BC.blk);
+    // obstacles
+    for (const o of obstacles) {
+      if (o.x<0||o.x>=W) continue;
+      for (let h=0;h<o.h;h++) {
+        const row=GROUND-h;
+        for (let w=0;w<o.w;w++) cv.put(o.x+w,row,h===0?'╤':'║',FC.grn,BC.blk);
+      }
+    }
+    if (state==='gameover') cv.put((W-28)>>1,4,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: BREAKOUT ──────────────────────────────────────────────────────────
+
+function makeBreakout(opts = {}) {
+  const W=50, H=24;
+  const ROWS=5, COLS=10, PAD_W=8, BALL_SPD=1;
+  const BROW_COLORS=[FC.RED,FC.YEL,FC.GRN,FC.CYN,FC.BLU];
+  const em=makeEmitter();
+  let bricks, ball, padX, score, lives, state, elapsed;
+
+  function makeBricks() {
+    return Array.from({length:ROWS}, (_,r)=>
+      Array.from({length:COLS}, (_,c)=>({alive:true, row:r, col:c}))
+    ).flat();
+  }
+
+  function start() {
+    bricks=makeBricks();
+    padX=(W-PAD_W)>>1;
+    ball={x:25,y:18,dx:1,dy:-1};
+    score=0; lives=3; elapsed=0; state='playing';
+    em.emit('start');
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter'){ start(); return; }
+    if (state==='won'&&key==='enter'){ start(); return; }
+    if (state!=='playing') return;
+    if (key==='left')  padX=Math.max(0,padX-2);
+    if (key==='right') padX=Math.min(W-PAD_W,padX+2);
+  }
+
+  function step() {
+    let nx=ball.x+ball.dx, ny=ball.y+ball.dy;
+    // wall bounces
+    if (nx<=0||nx>=W-1) { ball.dx=-ball.dx; nx=ball.x+ball.dx; }
+    if (ny<=1)           { ball.dy=-ball.dy; ny=ball.y+ball.dy; }
+    // paddle
+    if (ny>=H-3 && nx>=padX && nx<padX+PAD_W && ball.dy>0) {
+      ball.dy=-ball.dy;
+      ball.dx = ((nx-padX)/PAD_W*4-2)|0 || ball.dx;
+      ball.dx = clamp(ball.dx,-2,2); if(!ball.dx) ball.dx=1;
+      ny=ball.y+ball.dy;
+    }
+    // miss
+    if (ny>=H-1) {
+      lives--; if (!lives) { state='gameover'; em.emit('gameover',score); return; }
+      ball={x:25,y:18,dx:ball.dx>0?1:-1,dy:-1};
+      return;
+    }
+    // brick collision
+    for (const b of bricks) {
+      if (!b.alive) continue;
+      const bx=(b.col*5)+0, by=b.row+2;
+      if (nx>=bx&&nx<bx+5&&ny===by) {
+        b.alive=false; ball.dy=-ball.dy; ny=ball.y+ball.dy;
+        score+=10*(ROWS-b.row); em.emit('score',score); break;
+      }
+    }
+    ball.x=nx; ball.y=ny;
+    if (bricks.every(b=>!b.alive)) { state='won'; em.emit('win',score); }
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    while (elapsed>=80) { elapsed-=80; step(); }
+  }
+
+  function frame() {
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` BREAKOUT  Score:${score}  Lives:${'♥'.repeat(lives)}  [←→ Move]`,FC.YEL,BC.blk);
+    cv.put(0,1,'─'.repeat(W),FC.wht,BC.blk);
+    // bricks
+    for (const b of bricks) {
+      if (!b.alive) continue;
+      const bx=b.col*5, by=b.row+2;
+      cv.put(bx,by,'▓▓▓▓▓',BROW_COLORS[b.row],BC.blk);
+    }
+    // ball
+    cv.set(ball.x,ball.y,'●',FC.WHT,BC.blk);
+    // paddle
+    cv.put(padX,H-2,'▀'.repeat(PAD_W),FC.CYN,BC.blk);
+    cv.put(0,H-1,'─'.repeat(W),FC.BLK,BC.blk);
+    if (state==='gameover') cv.put((W-28)>>1,H>>1,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    if (state==='won')      cv.put((W-24)>>1,H>>1,'  YOU WIN!  ENTER to play again ',FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: SPACE INVADERS ────────────────────────────────────────────────────
+
+function makeSpaceInvaders(opts = {}) {
+  const W=60,H=24,COLS=10,ROWS=4;
+  const em=makeEmitter();
+  let aliens,alienDir,alienDx,playerX,bullets,aBullets,score,lives,state,elapsed,fireTimer;
+
+  const ALIEN_CH = ['◉◉','▓▓','░░','▒▒'];
+
+  function spawnAliens() {
+    aliens=[];
+    for (let r=0;r<ROWS;r++) for (let c=0;c<COLS;c++)
+      aliens.push({x:c*5+5,y:r*2+2,alive:true,row:r});
+    alienDir=1; alienDx=0;
+  }
+
+  function start() {
+    spawnAliens(); playerX=W>>1; bullets=[]; aBullets=[]; fireTimer=0;
+    score=0; lives=3; elapsed=0; state='playing'; em.emit('start');
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter'){ start(); return; }
+    if (state!=='playing') return;
+    if (key==='left')  playerX=Math.max(1,playerX-3);
+    if (key==='right') playerX=Math.min(W-2,playerX+3);
+    if (key==='space'||key==='z') bullets.push({x:playerX,y:H-4});
+  }
+
+  function step() {
+    const alive=aliens.filter(a=>a.alive);
+    if (!alive.length) { state='won'; em.emit('win',score); return; }
+
+    // move aliens
+    alienDx+=alienDir;
+    const minX=Math.min(...alive.map(a=>a.x));
+    const maxX=Math.max(...alive.map(a=>a.x))+2;
+    if (maxX>=W-1||minX<=1) {
+      alienDir=-alienDir;
+      for (const a of aliens) a.y++;
+      alienDx=0;
+    } else {
+      for (const a of aliens) a.x+=alienDir;
+    }
+
+    // aliens reached bottom
+    if (alive.some(a=>a.y>=H-4)) { state='gameover'; em.emit('gameover',score); return; }
+
+    // alien fire
+    fireTimer--;
+    if (fireTimer<=0) {
+      fireTimer=8+rng(12);
+      const shooter=alive[rng(alive.length)];
+      if (shooter) aBullets.push({x:shooter.x+1,y:shooter.y+1});
+    }
+
+    // move bullets
+    bullets  = bullets.filter(b=>b.y>1).map(b=>({...b,y:b.y-2}));
+    aBullets = aBullets.filter(b=>b.y<H-2).map(b=>({...b,y:b.y+1}));
+
+    // bullet hits alien
+    for (const b of [...bullets]) {
+      for (const a of alive) {
+        if (Math.abs(b.x-a.x)<=1&&Math.abs(b.y-a.y)<=1) {
+          a.alive=false; bullets=bullets.filter(x=>x!==b);
+          score+=(ROWS-a.row)*10; em.emit('score',score); break;
+        }
+      }
+    }
+
+    // alien bullet hits player
+    for (const b of aBullets) {
+      if (Math.abs(b.x-playerX)<=1&&b.y>=H-4) {
+        aBullets=aBullets.filter(x=>x!==b); lives--;
+        if (!lives) { state='gameover'; em.emit('gameover',score); return; }
+      }
+    }
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    const sp=Math.max(60,200-score/2|0);
+    while (elapsed>=sp) { elapsed-=sp; step(); if(state!=='playing') break; }
+  }
+
+  function frame() {
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` SPACE INVADERS  Score:${score}  Lives:${'♥'.repeat(lives)}  [←→ Move  SPACE Fire]`,FC.YEL,BC.blk);
+    cv.put(0,1,'═'.repeat(W),FC.BLU,BC.blk);
+    for (const a of aliens) if (a.alive)
+      cv.put(a.x,a.y,ALIEN_CH[a.row],FC.GRN-a.row,BC.blk);
+    for (const b of bullets)  cv.set(b.x,b.y,'|',FC.WHT,BC.blk);
+    for (const b of aBullets) cv.set(b.x,b.y,'!',FC.RED,BC.blk);
+    cv.put(playerX-1,H-3,'╔═╗',FC.CYN,BC.blk);
+    cv.put(playerX-2,H-2,'▓▓▓▓▓',FC.CYN,BC.blk);
+    cv.put(0,H-1,'═'.repeat(W),FC.wht,BC.blk);
+    if (state==='gameover') cv.put((W-28)>>1,H>>1,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    if (state==='won')      cv.put((W-24)>>1,H>>1,'  CLEARED!  ENTER for more  ',FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: FLAPPY BIRD ───────────────────────────────────────────────────────
+
+function makeFlappyBird(opts = {}) {
+  const W=60,H=20,BIRD_X=10,GAP=6;
+  const em=makeEmitter();
+  let birdY,velY,pipes,score,state,elapsed,speed;
+
+  function start() {
+    birdY=H>>1; velY=0; pipes=[]; score=0; elapsed=0; speed=120; state='playing';
+    pipes.push({x:W+5, gap:4+rng(H-GAP-4)});
+    em.emit('start');
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter'){ start(); return; }
+    if (state==='idle'&&(key==='space'||key==='enter')){ state='playing'; return; }
+    if (state!=='playing') return;
+    if (key==='space'||key==='up') velY=-1.1;
+  }
+
+  function step() {
+    velY+=0.25; birdY+=velY;
+    if (birdY<0||birdY>=H-1) { state='gameover'; em.emit('gameover',score); return; }
+
+    for (const p of pipes) {
+      p.x--;
+      if (Math.abs(p.x-BIRD_X)<2) {
+        if (birdY<p.gap||birdY>p.gap+GAP) { state='gameover'; em.emit('gameover',score); return; }
+      }
+      if (p.x===BIRD_X-1) { score++; speed=Math.max(60,speed-3); em.emit('score',score); }
+    }
+    pipes=pipes.filter(p=>p.x>-2);
+    if (!pipes.length||pipes[pipes.length-1].x<W-15+rng(5))
+      pipes.push({x:W+2,gap:2+rng(H-GAP-3)});
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    while (elapsed>=speed) { elapsed-=speed; step(); if(state!=='playing') break; }
+  }
+
+  function frame() {
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.BLU,BC.blk);
+    cv.put(0,0,` FLAPPY BIRD  Score:${score}  SPACE to flap`,FC.YEL,BC.blk);
+    for (const p of pipes) {
+      if (p.x<0||p.x>=W) continue;
+      for (let y=1;y<H;y++) {
+        if (y<p.gap||y>p.gap+GAP)
+          cv.put(p.x,y,'│▓',FC.grn,BC.blk);
+      }
+      cv.put(p.x,p.gap,'╙─',FC.GRN,BC.blk);
+      cv.put(p.x,p.gap+GAP,'╒─',FC.GRN,BC.blk);
+    }
+    const by=Math.round(birdY);
+    cv.put(BIRD_X,by, velY<0?'>O)':'>o)',FC.YEL,BC.blk);
+    if (state==='gameover') cv.put((W-28)>>1,H>>1,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: ASTEROIDS (DODGE) ─────────────────────────────────────────────────
+
+function makeAsteroids(opts = {}) {
+  const W=60,H=20;
+  const em=makeEmitter();
+  let px,py,rocks,score,state,elapsed,speed;
+  const ROCK_CHARS=['●','◉','◎','○','◈','◇'];
+
+  function spawnRock() {
+    return {x:W-1, y:rng(H-2)+1, w:1+rng(2), speed:1+rng(3)/3, ch:ROCK_CHARS[rng(ROCK_CHARS.length)]};
+  }
+
+  function start() {
+    px=10; py=H>>1; rocks=[]; score=0; elapsed=0; speed=60; state='playing';
+    for (let i=0;i<3;i++) rocks.push({...spawnRock(),x:W-5-rng(30)});
+    em.emit('start');
+  }
+
+  function input(key) {
+    if (state==='gameover'&&key==='enter'){ start(); return; }
+    if (state!=='playing') return;
+    if (key==='up')    py=Math.max(1,py-1);
+    if (key==='down')  py=Math.min(H-2,py+1);
+    if (key==='left')  px=Math.max(0,px-2);
+    if (key==='right') px=Math.min(W-3,px+2);
+  }
+
+  function tick(dt=16) {
+    if (state!=='playing') return;
+    elapsed+=dt;
+    if (elapsed<speed) return; elapsed=0;
+    score++; speed=Math.max(30,60-score/30|0);
+
+    for (const r of rocks) r.x-=r.speed;
+    rocks=rocks.filter(r=>r.x>-3);
+    while (rocks.length<4+((score/100)|0)) rocks.push(spawnRock());
+
+    // collision
+    for (const r of rocks) {
+      if (Math.abs(r.x-px)<=2&&Math.abs(r.y-py)<=1) {
+        state='gameover'; em.emit('gameover',score); return;
+      }
+    }
+    em.emit('score',score);
+  }
+
+  function frame() {
+    const cv=makeCanvas(W,H); cv.clear('·',FC.BLK,BC.blk);
+    cv.put(0,0,` ASTEROIDS  Score:${score}  [WASD/Arrows dodge rocks]`,FC.YEL,BC.blk);
+    for (const r of rocks) {
+      const rx=Math.round(r.x);
+      if (rx>=0&&rx<W) cv.put(rx,r.y,r.ch.repeat(r.w),FC.RED,BC.blk);
+    }
+    cv.put(px,py,'<Ö>',FC.CYN,BC.blk);
+    if (state==='gameover') cv.put((W-28)>>1,H>>1,'  GAME OVER  ENTER to restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: 2048 ──────────────────────────────────────────────────────────────
+
+function makeTwentyFortyEight(opts = {}) {
+  const SIZE=4;
+  const em=makeEmitter();
+  let board, score, best, state;
+
+  const TILE_COLORS = {
+    0:FC.BLK, 2:FC.wht, 4:FC.yel, 8:FC.YEL, 16:FC.mag, 32:FC.MAG,
+    64:FC.red, 128:FC.RED, 256:FC.grn, 512:FC.GRN, 1024:FC.cyn, 2048:FC.CYN,
+  };
+
+  function newBoard() { return Array.from({length:SIZE},()=>new Array(SIZE).fill(0)); }
+  function spawnTile(b) {
+    const empty=[];
+    for (let r=0;r<SIZE;r++) for (let c=0;c<SIZE;c++) if(!b[r][c]) empty.push([r,c]);
+    if (!empty.length) return;
+    const [r,c]=empty[rng(empty.length)];
+    b[r][c]=Math.random()<0.9?2:4;
+  }
+
+  function slide(row) {
+    const r=row.filter(x=>x);
+    let gain=0;
+    for (let i=0;i<r.length-1;i++) if(r[i]===r[i+1]) { r[i]*=2; gain+=r[i]; r.splice(i+1,1); }
+    while (r.length<SIZE) r.push(0);
+    return {row:r, gain};
+  }
+
+  function move(dir) {
+    let moved=false, gain=0;
+    const nb=newBoard();
+    for (let r=0;r<SIZE;r++) for (let c=0;c<SIZE;c++) nb[r][c]=board[r][c];
+
+    if (dir==='left'||dir==='right') {
+      for (let r=0;r<SIZE;r++) {
+        let row=nb[r]; if (dir==='right') row=[...row].reverse();
+        const {row:nr,gain:g}=slide(row);
+        if (dir==='right') nr.reverse();
+        if (nr.some((v,i)=>v!==nb[r][i])) moved=true;
+        nb[r]=nr; gain+=g;
+      }
+    } else {
+      for (let c=0;c<SIZE;c++) {
+        let col=nb.map(r=>r[c]); if (dir==='down') col=[...col].reverse();
+        const {row:nc,gain:g}=slide(col);
+        if (dir==='down') nc.reverse();
+        nc.forEach((v,r)=>{ if(v!==nb[r][c]) moved=true; nb[r][c]=v; });
+        gain+=g;
+      }
+    }
+    if (!moved) return false;
+    board=nb; score+=gain; best=Math.max(best,score);
+    spawnTile(board); em.emit('score',score);
+    // check win
+    if (board.flat().includes(2048)) { state='won'; em.emit('win',score); }
+    // check game over
+    else if (!canMove()) { state='gameover'; em.emit('gameover',score); }
+    return true;
+  }
+
+  function canMove() {
+    for (let r=0;r<SIZE;r++) for (let c=0;c<SIZE;c++) {
+      if (!board[r][c]) return true;
+      if (c<SIZE-1&&board[r][c]===board[r][c+1]) return true;
+      if (r<SIZE-1&&board[r][c]===board[r+1][c]) return true;
+    }
+    return false;
+  }
+
+  function start() {
+    board=newBoard(); score=0; best=best??0; state='playing';
+    spawnTile(board); spawnTile(board); em.emit('start');
+  }
+
+  function input(key) {
+    if ((state==='gameover'||state==='won')&&key==='enter'){ start(); return; }
+    if (state!=='playing') return;
+    if (['up','down','left','right'].includes(key)) move(key);
+  }
+
+  function frame() {
+    const CW=5*SIZE+3, CH=SIZE*2+4;
+    const cv=makeCanvas(CW+20,CH); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` 2048  Score:${score}  Best:${best}  [Arrows]`,FC.YEL,BC.blk);
+    cv.box(0,1,CW,CH-1,FC.wht,BC.blk);
+    for (let r=0;r<SIZE;r++) for (let c=0;c<SIZE;c++) {
+      const v=board[r][c];
+      const col=TILE_COLORS[v]??FC.WHT;
+      const s=(v?String(v):'·').padStart(4,' ');
+      cv.put(c*5+1,r*2+2,s,col,BC.blk);
+      if (r<SIZE-1) cv.put(c*5+1,r*2+3,'────',FC.BLK,BC.blk);
+    }
+    if (state==='gameover') cv.put(1,(CH>>1),'  GAME OVER  ENTER restart  ',FC.WHT,BC.red);
+    if (state==='won')      cv.put(1,(CH>>1),'  2048! ENTER continue  ',FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: MINESWEEPER ───────────────────────────────────────────────────────
+
+function makeMinesweeper(opts = {}) {
+  const GW=opts.w??9,GH=opts.h??9,MINES=opts.mines??10;
+  const em=makeEmitter();
+  let cells,cx,cy,state,score,revealed,firstClick;
+
+  function idx(x,y){return y*GW+x;}
+  function neighbors(x,y){
+    const n=[];
+    for(let dy=-1;dy<=1;dy++) for(let dx=-1;dx<=1;dx++) {
+      if(dx||dy) { const nx=x+dx,ny=y+dy; if(nx>=0&&nx<GW&&ny>=0&&ny<GH) n.push([nx,ny]); }
+    }
+    return n;
+  }
+
+  function placeMines(safeX,safeY) {
+    let placed=0;
+    while(placed<MINES) {
+      const x=rng(GW),y=rng(GH);
+      if(!cells[idx(x,y)].mine&&!(Math.abs(x-safeX)<=1&&Math.abs(y-safeY)<=1)) {
+        cells[idx(x,y)].mine=true; placed++;
+      }
+    }
+    for(let y=0;y<GH;y++) for(let x=0;x<GW;x++)
+      cells[idx(x,y)].adj=neighbors(x,y).filter(([nx,ny])=>cells[idx(nx,ny)].mine).length;
+  }
+
+  function reveal(x,y) {
+    const c=cells[idx(x,y)];
+    if(c.revealed||c.flagged) return;
+    c.revealed=true; revealed++;
+    if(c.mine) { state='gameover'; em.emit('gameover',score); return; }
+    if(!c.adj) neighbors(x,y).forEach(([nx,ny])=>reveal(nx,ny));
+    if(revealed===GW*GH-MINES) { state='won'; score=1000; em.emit('win',score); }
+  }
+
+  function start() {
+    cells=Array.from({length:GW*GH},()=>({mine:false,revealed:false,flagged:false,adj:0}));
+    cx=GW>>1; cy=GH>>1; revealed=0; score=0; state='playing'; firstClick=true;
+    em.emit('start');
+  }
+
+  function input(key) {
+    if((state==='gameover'||state==='won')&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(key==='up')    cy=Math.max(0,cy-1);
+    if(key==='down')  cy=Math.min(GH-1,cy+1);
+    if(key==='left')  cx=Math.max(0,cx-1);
+    if(key==='right') cx=Math.min(GW-1,cx+1);
+    if(key==='space'||key==='enter') {
+      if(firstClick) { firstClick=false; placeMines(cx,cy); }
+      reveal(cx,cy);
+    }
+    if(key==='f') {
+      const c=cells[idx(cx,cy)];
+      if(!c.revealed) { c.flagged=!c.flagged; score+=c.flagged?5:-5; }
+    }
+  }
+
+  function frame() {
+    const W=GW*3+4, H=GH+4;
+    const cv=makeCanvas(W+20,H); cv.clear(' ',FC.wht,BC.blk);
+    const flags=cells.filter(c=>c.flagged).length;
+    cv.put(0,0,` MINESWEEPER  Mines:${MINES-flags}  [Arrows Move  SPACE reveal  F flag  ENTER restart]`,FC.YEL,BC.blk);
+    const numColors=[FC.wht,FC.BLU,FC.GRN,FC.RED,FC.BLU,FC.RED,FC.CYN,FC.MAG,FC.wht];
+    for(let y=0;y<GH;y++) {
+      cv.put(0,y+2,'│',FC.wht,BC.blk);
+      for(let x=0;x<GW;x++) {
+        const c=cells[idx(x,y)];
+        const isCur=x===cx&&y===cy;
+        let disp=' ·',fg=FC.BLK;
+        if(c.flagged&&!c.revealed)   { disp=' ⚑'; fg=FC.RED; }
+        else if(!c.revealed)          { disp=isCur?' ▪':' ▫'; fg=isCur?FC.YEL:FC.BLK; }
+        else if(c.mine)               { disp=' ✸'; fg=FC.RED; }
+        else if(c.adj)                { disp=` ${c.adj}`; fg=numColors[c.adj]; }
+        else                          { disp='  '; fg=FC.BLK; }
+        cv.put(x*3+1,y+2,disp,fg,isCur&&!c.revealed?BC.BLK:BC.blk);
+      }
+      cv.put(GW*3+1,y+2,'│',FC.wht,BC.blk);
+    }
+    cv.put(0,1,'├'+'─'.repeat(GW*3)+'┤',FC.wht,BC.blk);
+    cv.put(0,GH+2,'└'+'─'.repeat(GW*3)+'┘',FC.wht,BC.blk);
+    if(state==='gameover') { 
+      for(const c of cells) if(c.mine&&!c.flagged) c.revealed=true;
+      cv.put(1,GH+3,'  BOOM!  ENTER to restart  ',FC.WHT,BC.red);
+    }
+    if(state==='won') cv.put(1,GH+3,'  CLEARED!  ENTER again  ',FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: WORDLE ────────────────────────────────────────────────────────────
+
+function makeWordle(opts = {}) {
+  const em=makeEmitter();
+  let target,guesses,current,state,score,msg;
+
+  function start() {
+    target=WORDLE_WORDS[rng(WORDLE_WORDS.length)].toUpperCase();
+    guesses=[]; current=''; state='playing'; score=0; msg='';
+    em.emit('start');
+  }
+
+  function check(word) {
+    const result=[];
+    const tArr=[...target];
+    const used=new Array(5).fill(false);
+    // greens
+    for(let i=0;i<5;i++) {
+      if(word[i]===tArr[i]) { result[i]='green'; used[i]=true; }
+    }
+    // yellows
+    for(let i=0;i<5;i++) {
+      if(result[i]) continue;
+      const j=tArr.findIndex((c,k)=>c===word[i]&&!used[k]);
+      if(j>=0) { result[i]='yellow'; used[j]=true; }
+      else result[i]='gray';
+    }
+    return result;
+  }
+
+  function input(key) {
+    if((state==='gameover'||state==='won')&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(key==='enter') {
+      if(current.length<5) { msg='Too short!'; return; }
+      if(!WORDLE_WORDS.includes(current.toLowerCase())&&!WORDLE_WORDS.includes(current.toUpperCase())) { msg='Not in word list'; return; }
+      const colors=check(current);
+      guesses.push({word:current,colors});
+      if(current===target) {
+        score=Math.max(10,(7-guesses.length)*100); state='won';
+        msg='Brilliant!'; em.emit('win',score); return;
+      }
+      if(guesses.length>=6) { state='gameover'; msg=`Word was: ${target}`; em.emit('gameover',0); return; }
+      current=''; msg='';
+    } else if(key==='backspace'||key==='delete') {
+      current=current.slice(0,-1);
+    } else if(/^[a-z]$/.test(key)&&current.length<5) {
+      current+=key.toUpperCase();
+    }
+  }
+
+  const GC={green:FC.GRN,yellow:FC.YEL,gray:FC.BLK};
+
+  function frame() {
+    const W=40,H=20;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,' WORDLE  [Type guess, ENTER submit, BACKSPACE]',FC.YEL,BC.blk);
+    // grid
+    for(let g=0;g<6;g++) {
+      const guess=guesses[g];
+      for(let l=0;l<5;l++) {
+        const bx=l*6+2, by=g*2+2;
+        if(guess) {
+          const col=GC[guess.colors[l]];
+          cv.put(bx,by,`[${guess.word[l]}]`,col,BC.blk);
+        } else if(g===guesses.length&&l<current.length) {
+          cv.put(bx,by,`[${current[l]}]`,FC.WHT,BC.blk);
+        } else {
+          cv.put(bx,by,'[ ]',FC.BLK,BC.blk);
+        }
+      }
+    }
+    // keyboard hint
+    const kb='QWERTYUIOPASDFGHJKLZXCVBNM';
+    const usedLetters=new Map();
+    for(const g of guesses) {
+      for(let i=0;i<5;i++) {
+        const l=g.word[i], c=g.colors[i];
+        if(!usedLetters.has(l)||c==='green'||(c==='yellow'&&usedLetters.get(l)==='gray'))
+          usedLetters.set(l,c);
+      }
+    }
+    const rows=['QWERTYUIOP','ASDFGHJKL','ZXCVBNM'];
+    for(let r=0;r<3;r++) {
+      let x=2+r*3;
+      for(const ch of rows[r]) {
+        const col=GC[usedLetters.get(ch)]??FC.wht;
+        cv.put(x,14+r,ch,col,BC.blk); x+=3;
+      }
+    }
+    if(msg) cv.put(2,13,msg.padEnd(30,' '),FC.RED,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: CONNECT FOUR ──────────────────────────────────────────────────────
+
+function makeConnectFour(opts = {}) {
+  const COLS=7,ROWS=6;
+  const em=makeEmitter();
+  let board,curCol,turn,state,score,aiMode,msg;
+
+  function start() {
+    board=Array.from({length:ROWS},()=>new Array(COLS).fill(0));
+    curCol=3; turn=1; state='playing'; score=0; msg='';
+    aiMode=opts.ai??true;
+    em.emit('start');
+  }
+
+  function dropPiece(col,player) {
+    for(let r=ROWS-1;r>=0;r--) {
+      if(!board[r][col]) { board[r][col]=player; return r; }
+    }
+    return -1;
+  }
+
+  function checkWin(player) {
+    // horizontal/vertical/diagonal
+    for(let r=0;r<ROWS;r++) for(let c=0;c<COLS;c++) {
+      const dirs=[[0,1],[1,0],[1,1],[1,-1]];
+      for(const [dr,dc] of dirs) {
+        let cnt=0;
+        for(let i=0;i<4;i++) {
+          const nr=r+dr*i,nc=c+dc*i;
+          if(nr>=0&&nr<ROWS&&nc>=0&&nc<COLS&&board[nr][nc]===player) cnt++;
+          else break;
+        }
+        if(cnt===4) return true;
+      }
+    }
+    return false;
+  }
+
+  function aiMove() {
+    const valid=[];
+    for(let c=0;c<COLS;c++) if(board[0][c]===0) valid.push(c);
+    if(!valid.length) return;
+    // check win
+    for(const c of valid) {
+      const r=dropPiece(c,2); if(checkWin(2)) { board[r][c]=0; return c; } board[r][c]=0;
+    }
+    // block player win
+    for(const c of valid) {
+      const r=dropPiece(c,1); if(checkWin(1)) { board[r][c]=0; return c; } board[r][c]=0;
+    }
+    // prefer center
+    const prio=[3,2,4,1,5,0,6].filter(c=>valid.includes(c));
+    return prio[0];
+  }
+
+  function play(col) {
+    if(board[0][col]!==0) { msg='Column full!'; return; }
+    const r=dropPiece(col,turn);
+    if(checkWin(turn)) {
+      msg=`Player ${turn} wins!`; score=turn===1?100:0; state='gameover';
+      em.emit('gameover',score); return;
+    }
+    if(board.every(row=>row.every(c=>c!==0))) { msg='Draw!'; state='gameover'; em.emit('gameover',0); return; }
+    turn=turn===1?2:1;
+    if(aiMode&&turn===2) {
+      const ac=aiMove();
+      if(ac!==undefined) {
+        const ar=dropPiece(ac,2);
+        if(checkWin(2)) { msg='AI wins!'; state='gameover'; em.emit('gameover',0); return; }
+        turn=1;
+      }
+    }
+    msg='';
+  }
+
+  function input(key) {
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(key==='left')  curCol=Math.max(0,curCol-1);
+    if(key==='right') curCol=Math.min(COLS-1,curCol+1);
+    if(key==='space'||key==='down'||key==='enter') play(curCol);
+  }
+
+  function frame() {
+    const W=COLS*4+4,H=ROWS+6;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` CONNECT FOUR  ${aiMode?'vs AI':'2P'}  [←→ column  SPACE/↓ drop]`,FC.YEL,BC.blk);
+    // cursor
+    cv.put(curCol*4+2,1,'▼',turn===1?FC.RED:FC.YEL,BC.blk);
+    // board
+    cv.put(0,2,'┌'+'───┬'.repeat(COLS-1)+'───┐',FC.wht,BC.blk);
+    for(let r=0;r<ROWS;r++) {
+      let row='│';
+      for(let c=0;c<COLS;c++) {
+        const v=board[r][c];
+        const ch=v===0?' ○ ':v===1?' ● ':' ◉ ';
+        const col=v===0?FC.BLK:v===1?FC.RED:FC.YEL;
+        cv.put(row.length,r*2+3,ch,col,BC.blk); row+=ch+'│';
+      }
+      cv.put(0,r*2+3,'│',FC.wht,BC.blk); cv.put(W-1,r*2+3,'│',FC.wht,BC.blk);
+      if(r<ROWS-1) cv.put(0,r*2+4,'├'+'───┼'.repeat(COLS-1)+'───┤',FC.wht,BC.blk);
+    }
+    cv.put(0,ROWS*2+3,'└'+'───┴'.repeat(COLS-1)+'───┘',FC.wht,BC.blk);
+    if(msg) cv.put(1,ROWS*2+4,' '+msg.padEnd(W-2,' ')+'',FC.WHT,BC.blk);
+    if(state==='gameover') cv.put(2,ROWS*2+5,'ENTER to play again',FC.GRN,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: BATTLESHIP ────────────────────────────────────────────────────────
+
+function makeBattleship(opts = {}) {
+  const SZ=10;
+  const SHIPS=[{n:'Carrier',sz:5},{n:'Battleship',sz:4},{n:'Cruiser',sz:3},{n:'Submarine',sz:3},{n:'Destroyer',sz:2}];
+  const em=makeEmitter();
+  let pBoard,pHits,aBoard,aHits,aCursor,pCursor,state,score,msg,phase,aHunt,aTargets;
+
+  function makeBoard(){return new Array(SZ*SZ).fill(0);}
+  function placeShips(board){
+    for(const s of SHIPS){
+      let placed=false;
+      while(!placed){
+        const horiz=Math.random()<0.5;
+        const x=rng(horiz?SZ-s.sz+1:SZ);
+        const y=rng(horiz?SZ:SZ-s.sz+1);
+        let ok=true;
+        for(let i=0;i<s.sz;i++){
+          const nx=x+(horiz?i:0),ny=y+(horiz?0:i);
+          if(board[ny*SZ+nx]){ok=false;break;}
+        }
+        if(ok){for(let i=0;i<s.sz;i++){const nx=x+(horiz?i:0),ny=y+(horiz?0:i);board[ny*SZ+nx]=1;}placed=true;}
+      }
+    }
+  }
+
+  function start(){
+    pBoard=makeBoard(); placeShips(pBoard);
+    aBoard=makeBoard(); placeShips(aBoard);
+    pHits=new Array(SZ*SZ).fill(0); aHits=new Array(SZ*SZ).fill(0);
+    pCursor=[0,0]; aCursor=[0,0];
+    aHunt=[]; aTargets=[]; score=0; state='playing'; msg='Your turn! [Arrows aim, SPACE fire]';
+    em.emit('start');
+  }
+
+  function aiShoot(){
+    let x,y;
+    if(aTargets.length){
+      [x,y]=aTargets.shift();
+    } else {
+      if(!aHunt.length){
+        for(let i=0;i<SZ*SZ;i++) aHunt.push([i%SZ,i/SZ|0]);
+        aHunt=shuffle(aHunt);
+      }
+      [x,y]=aHunt.shift();
+    }
+    aCursor=[x,y];
+    if(aHits[y*SZ+x]) return aiShoot();
+    aHits[y*SZ+x]=pBoard[y*SZ+x]?2:1;
+    if(pBoard[y*SZ+x]){
+      msg='AI hit your ship!';
+      [[x-1,y],[x+1,y],[x,y-1],[x,y+1]].filter(([nx,ny])=>nx>=0&&nx<SZ&&ny>=0&&ny<SZ&&!aHits[ny*SZ+nx])
+        .forEach(p=>aTargets.push(p));
+    } else msg='AI missed.';
+    if(aHits.filter((v,i)=>v===2&&pBoard[i]).length===SHIPS.reduce((s,sh)=>s+sh.sz,0)){
+      state='gameover'; msg='AI wins!'; em.emit('gameover',0);
+    }
+  }
+
+  function input(key){
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    const [cx,cy]=pCursor;
+    if(key==='up')    pCursor=[cx,Math.max(0,cy-1)];
+    if(key==='down')  pCursor=[cx,Math.min(SZ-1,cy+1)];
+    if(key==='left')  pCursor=[Math.max(0,cx-1),cy];
+    if(key==='right') pCursor=[Math.min(SZ-1,cx+1),cy];
+    if(key==='space'||key==='enter'){
+      const [px,py]=pCursor;
+      if(pHits[py*SZ+px]){msg='Already fired there!';return;}
+      pHits[py*SZ+px]=aBoard[py*SZ+px]?2:1;
+      if(aBoard[py*SZ+px]){
+        score+=50; msg='Hit!';
+        if(pHits.filter((v,i)=>v===2&&aBoard[i]).length===SHIPS.reduce((s,sh)=>s+sh.sz,0)){
+          state='won'; msg='You win!'; em.emit('win',score); return;
+        }
+      } else msg='Miss.';
+      aiShoot();
+    }
+  }
+
+  function renderBoard(cv,ox,oy,board,hits,cursor,showShips,label){
+    cv.put(ox,oy,label,FC.CYN,BC.blk);
+    for(let y=0;y<SZ;y++) for(let x=0;x<SZ;x++){
+      const h=hits[y*SZ+x];
+      const isCur=cursor&&cursor[0]===x&&cursor[1]===y;
+      const ship=board[y*SZ+x];
+      let ch='·',col=FC.BLK;
+      if(h===2){ch='✸';col=FC.RED;}
+      else if(h===1){ch='○';col=FC.BLU;}
+      else if(showShips&&ship){ch='▓';col=FC.GRN;}
+      if(isCur&&!h){ch='◎';col=FC.YEL;}
+      cv.set(ox+x*2,oy+y+1,ch,col,BC.blk);
+      cv.set(ox+x*2+1,oy+y+1,' ',FC.wht,BC.blk);
+    }
+  }
+
+  function frame(){
+    const W=50,H=18;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` BATTLESHIP  Score:${score}  [Arrows aim  SPACE fire]`,FC.YEL,BC.blk);
+    renderBoard(cv,1,1,aBoard,pHits,pCursor,false,'ENEMY WATERS:');
+    renderBoard(cv,26,1,pBoard,aHits,aCursor,true,'YOUR FLEET:');
+    cv.put(0,H-2,('  '+msg).padEnd(W,' '),FC.WHT,BC.blk);
+    if(state==='gameover'||state==='won') cv.put(0,H-1,'  ENTER to play again',FC.GRN,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: MAZE ──────────────────────────────────────────────────────────────
+
+function makeMaze(opts = {}) {
+  const MW=opts.w??21,MH=opts.h??21;
+  const em=makeEmitter();
+  let maze,px,py,steps,state,score,startTime;
+
+  function generate(){
+    // 2D boolean grid: true = wall
+    const m=Array.from({length:MH},()=>new Array(MW).fill(true));
+    // recursive backtracker (odd coords = cells, even = walls)
+    function carve(x,y){
+      m[y][x]=false;
+      const dirs=shuffle([[0,-2],[0,2],[-2,0],[2,0]]);
+      for(const [dx,dy] of dirs){
+        const nx=x+dx,ny=y+dy;
+        if(nx>0&&nx<MW-1&&ny>0&&ny<MH-1&&m[ny][nx]){
+          m[y+dy/2|0][x+dx/2|0]=false;
+          carve(nx,ny);
+        }
+      }
+    }
+    carve(1,1); return m;
+  }
+
+  function start(){
+    maze=generate(); px=1; py=1; steps=0; score=0;
+    maze[MH-2][MW-2]=false; // exit always open
+    state='playing'; startTime=Date.now();
+    em.emit('start');
+  }
+
+  function input(key){
+    if(state==='won'&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    const moves={up:[0,-1],down:[0,1],left:[-1,0],right:[1,0]};
+    const m=moves[key]; if(!m) return;
+    const nx=px+m[0],ny=py+m[1];
+    if(nx>=0&&nx<MW&&ny>=0&&ny<MH&&!maze[ny][nx]){ px=nx; py=ny; steps++; }
+    if(px===MW-2&&py===MH-2){
+      const t=Math.max(1,(Date.now()-startTime)/1000|0);
+      score=Math.max(10,500-steps-t); state='won'; em.emit('win',score);
+    }
+  }
+
+  function frame(){
+    const cv=makeCanvas(MW+24,MH+3); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` MAZE  Steps:${steps}  [Arrows to navigate  reach ★]`,FC.YEL,BC.blk);
+    for(let y=0;y<MH;y++) for(let x=0;x<MW;x++){
+      if(x===px&&y===py) cv.set(x,y+2,'@',FC.YEL,BC.blk);
+      else if(x===MW-2&&y===MH-2) cv.set(x,y+2,'★',FC.GRN,BC.blk);
+      else cv.set(x,y+2,maze[y][x]?'█':' ',maze[y][x]?FC.BLU:FC.wht,BC.blk);
+    }
+    cv.put(MW+2,2,`Player: ${px},${py}`,FC.CYN,BC.blk);
+    cv.put(MW+2,3,`Exit:   ${MW-2},${MH-2}`,FC.CYN,BC.blk);
+    if(state==='won'){cv.put(MW+2,5,'YOU MADE IT!',FC.GRN,BC.blk);cv.put(MW+2,6,`Score: ${score}`,FC.GRN,BC.blk);cv.put(MW+2,7,'ENTER new maze',FC.GRN,BC.blk);}
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: LIGHTS OUT ────────────────────────────────────────────────────────
+
+function makeLightsOut(opts = {}) {
+  const SZ=opts.size??5, SCRAMBLE=opts.scramble??15;
+  const em=makeEmitter();
+  let grid,cx,cy,moves,state,score;
+
+  function toggle(gx,gy){
+    [[0,0],[0,-1],[0,1],[-1,0],[1,0]].forEach(([dx,dy])=>{
+      const nx=gx+dx,ny=gy+dy;
+      if(nx>=0&&nx<SZ&&ny>=0&&ny<SZ) grid[ny*SZ+nx]^=1;
+    });
+  }
+
+  function start(){
+    grid=new Array(SZ*SZ).fill(0);
+    for(let i=0;i<SCRAMBLE;i++) toggle(rng(SZ),rng(SZ));
+    cx=SZ>>1; cy=SZ>>1; moves=0; score=0; state='playing';
+    em.emit('start');
+  }
+
+  function input(key){
+    if(state==='won'&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(key==='up')    cy=Math.max(0,cy-1);
+    if(key==='down')  cy=Math.min(SZ-1,cy+1);
+    if(key==='left')  cx=Math.max(0,cx-1);
+    if(key==='right') cx=Math.min(SZ-1,cx+1);
+    if(key==='space'||key==='enter'){
+      toggle(cx,cy); moves++;
+      if(grid.every(v=>v===0)){
+        score=Math.max(10,500-moves*10); state='won'; em.emit('win',score);
+      }
+    }
+  }
+
+  function frame(){
+    const W=SZ*6+4,H=SZ*3+6;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` LIGHTS OUT  Moves:${moves}  [Arrows  SPACE toggle — turn all lights off]`,FC.YEL,BC.blk);
+    for(let y=0;y<SZ;y++) for(let x=0;x<SZ;x++){
+      const on=grid[y*SZ+x];
+      const isCur=x===cx&&y===cy;
+      const bx=x*6+1,by=y*3+2;
+      const bcol=on?BC.YEL:BC.blk, fcol=on?FC.blk:FC.BLK;
+      cv.fill(bx,by,5,2,on?'█':' ',fcol,bcol);
+      if(isCur) cv.put(bx+1,by+0,' ◉  ',FC.WHT,bcol);
+    }
+    cv.put(1,H-2,`Score: ${score}`,FC.CYN,BC.blk);
+    if(state==='won'){cv.put(1,H-1,'  ALL OFF! ENTER new puzzle  ',FC.WHT,BC.grn);}
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: SUDOKU ────────────────────────────────────────────────────────────
+
+function makeSudoku(opts = {}) {
+  const em=makeEmitter();
+  let puzzle,board,given,cx,cy,state,score,errors,puzzleIdx;
+
+  function parsePuzzle(str){
+    return Array.from(str).map(c=>c==='.'?0:+c);
+  }
+
+  function start(){
+    puzzleIdx=(puzzleIdx??-1)+1; if(puzzleIdx>=SUDOKU_PUZZLES.length) puzzleIdx=0;
+    puzzle=parsePuzzle(SUDOKU_PUZZLES[puzzleIdx]);
+    board=[...puzzle]; given=puzzle.map(v=>v!==0);
+    cx=0; cy=0; errors=0; score=0; state='playing';
+    em.emit('start');
+  }
+
+  function isValid(b,pos,val){
+    const r=pos/9|0,c=pos%9;
+    for(let i=0;i<9;i++){
+      if(i!==c&&b[r*9+i]===val) return false;
+      if(i!==r&&b[i*9+c]===val) return false;
+    }
+    const br=r/3|0*3,bc=c/3|0*3;
+    for(let dr=0;dr<3;dr++) for(let dc=0;dc<3;dc++){
+      const ni=(br+dr)*9+(bc+dc);
+      if(ni!==pos&&b[ni]===val) return false;
+    }
+    return true;
+  }
+
+  function input(key){
+    if(state==='won'&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(key==='up')    cy=Math.max(0,cy-1);
+    if(key==='down')  cy=Math.min(8,cy+1);
+    if(key==='left')  cx=Math.max(0,cx-1);
+    if(key==='right') cx=Math.min(8,cx+1);
+    const pos=cy*9+cx;
+    if(/^[1-9]$/.test(key)&&!given[pos]){
+      const v=+key;
+      if(!isValid(board,pos,v)) errors++;
+      board[pos]=v;
+      if(board.every((v,i)=>v!==0&&isValid(board,i,v))){
+        score=Math.max(10,1000-errors*50); state='won'; em.emit('win',score);
+      }
+    }
+    if((key==='delete'||key==='backspace'||key==='0')&&!given[pos]) board[pos]=0;
+  }
+
+  function frame(){
+    const W=42,H=22;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` SUDOKU  Errors:${errors}  [Arrows move, 1-9 enter, DEL clear]`,FC.YEL,BC.blk);
+    // grid
+    for(let r=0;r<9;r++){
+      for(let c=0;c<9;c++){
+        const pos=r*9+c;
+        const v=board[pos];
+        const isCur=c===cx&&r===cy;
+        const isGiv=given[pos];
+        const bad=v&&!isValid(board,pos,v);
+        const ch=v?String(v):'.';
+        const fg=bad?FC.RED:isGiv?FC.WHT:FC.CYN;
+        const bg=isCur?BC.BLU:BC.blk;
+        cv.put(c*4+(c>5?2:c>2?1:0)+1, r*2+(r>5?2:r>2?1:0)+2, ` ${ch} `, fg, bg);
+      }
+    }
+    // grid lines
+    for(let i=0;i<3;i++) {
+      const row=i*6+1; const col_x=i*12+4;
+      cv.put(0,row+2,'─'.repeat(38),FC.BLK,BC.blk);
+      for(let r=0;r<10;r++) cv.set(col_x,r*2+2,'│',FC.BLK,BC.blk);
+    }
+    cv.put(1,H-2,`Score: ${score}  Puzzle: ${puzzleIdx+1}/${SUDOKU_PUZZLES.length}`,FC.CYN,BC.blk);
+    if(state==='won') cv.put(1,H-1,'  SOLVED!  ENTER next puzzle  ',FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: BLACKJACK ─────────────────────────────────────────────────────────
+
+function makeBlackjack(opts = {}) {
+  const em=makeEmitter();
+  let deck,pHand,dHand,chips,bet,state,score,msg;
+
+  const SUITS=['♠','♥','♦','♣'],RANKS=['A','2','3','4','5','6','7','8','9','10','J','Q','K'];
+  const SUIT_COL={'♠':FC.WHT,'♥':FC.RED,'♦':FC.RED,'♣':FC.WHT};
+
+  function makeDeck(){
+    const d=[];
+    for(const s of SUITS) for(const r of RANKS) d.push({r,s});
+    return shuffle(d);
+  }
+
+  function cardVal(r){ return r==='A'?11:['J','Q','K'].includes(r)?10:+r; }
+  function handVal(h){
+    let v=h.reduce((s,c)=>s+cardVal(c.r),0), aces=h.filter(c=>c.r==='A').length;
+    while(v>21&&aces>0){v-=10;aces--;}
+    return v;
+  }
+  function deal(){return deck.pop()??makeDeck().pop();}
+
+  function start(){
+    deck=makeDeck(); chips=opts.chips??100; bet=10; state='idle'; msg='Place your bet with +/-  then ENTER to deal';
+    em.emit('start');
+  }
+
+  function startRound(){
+    if(chips<=0){state='gameover';msg='Broke! Game over.';em.emit('gameover',chips);return;}
+    if(bet>chips) bet=chips;
+    pHand=[deal(),deal()]; dHand=[deal(),deal()];
+    state='playing'; msg='H=hit  S=stand  D=double  ENTER=stand';
+    if(handVal(pHand)===21){stand();}
+  }
+
+  function stand(){
+    while(handVal(dHand)<17) dHand.push(deal());
+    const pv=handVal(pHand),dv=handVal(dHand);
+    if(dv>21||pv>dv){chips+=bet;msg=`You win! +${bet}  (${pv} vs ${dv})`;}
+    else if(pv===dv){msg=`Push! Tie (${pv} vs ${dv})`;}
+    else{chips-=bet;msg=`You lose! -${bet}  (${pv} vs ${dv})`;}
+    score=chips; state='roundover'; em.emit('score',score);
+  }
+
+  function input(key){
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(state==='idle'){
+      if(key==='+') bet=Math.min(chips,bet+10);
+      if(key==='-') bet=Math.max(5,bet-10);
+      if(key==='enter'||key==='space') startRound();
+      return;
+    }
+    if(state==='roundover'){
+      if(key==='enter'||key==='space'){ state='idle'; msg='Place your bet with +/-  then ENTER to deal'; }
+      return;
+    }
+    if(state!=='playing') return;
+    if(key==='h'||key==='up'){
+      pHand.push(deal());
+      if(handVal(pHand)>21){chips-=bet;msg=`Bust! -${bet}`;score=chips;state='roundover';em.emit('score',score);}
+    }
+    if(key==='s'||key==='enter'||key==='down') stand();
+    if(key==='d'){
+      bet=Math.min(bet*2,chips); pHand.push(deal());
+      if(handVal(pHand)>21){chips-=bet;msg=`Double bust! -${bet}`;score=chips;state='roundover';}
+      else stand();
+    }
+  }
+
+  function cardStr(c,hidden=false){
+    return hidden?'[??]':`[${c.r}${c.s}]`;
+  }
+
+  function frame(){
+    const W=50,H=18;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` BLACKJACK  Chips:${chips}  Bet:${bet}  [H=hit S=stand D=double  +/- bet]`,FC.YEL,BC.blk);
+    cv.put(1,2,'DEALER: ',FC.CYN,BC.blk);
+    let dx=9;
+    const showAll=state==='roundover'||state==='gameover';
+    for(let i=0;i<dHand.length;i++){
+      const c=dHand[i], hidden=!showAll&&i===1;
+      const cs=cardStr(c,hidden);
+      cv.put(dx,2,cs,hidden?FC.BLK:SUIT_COL[c.s],BC.blk); dx+=cs.length+1;
+    }
+    if(showAll) cv.put(dx+1,2,`= ${handVal(dHand)}`,FC.CYN,BC.blk);
+    cv.put(1,5,'PLAYER: ',FC.CYN,BC.blk);
+    let px2=9;
+    for(const c of pHand){ const cs=cardStr(c); cv.put(px2,5,cs,SUIT_COL[c.s],BC.blk); px2+=cs.length+1; }
+    cv.put(px2+1,5,`= ${handVal(pHand)}`,FC.GRN,BC.blk);
+    cv.put(1,8,msg.padEnd(W-2,' '),FC.WHT,BC.blk);
+    if(state==='gameover') cv.put(1,10,'ENTER to restart',FC.RED,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score??chips;} };
+}
+
+// ─── GAME: SLOTS ─────────────────────────────────────────────────────────────
+
+function makeSlots(opts = {}) {
+  const em=makeEmitter();
+  const SYMS=[' 7 ','BAR','BEL','CHR','LMN','ORG','PLM'];
+  const SYM_COL=[FC.YEL,FC.WHT,FC.YEL,FC.RED,FC.YEL,FC.YEL,FC.MAG];
+  const WEIGHTS=[1,2,3,4,4,3,3];
+  const PAY={'7 7 7':500,'BARBAR':200,'BELBEL':100,'CHRCHR':50,'LMNLMN':30,'ORGORG':30,'PLMPLM':20};
+  let reels,spinning,spinFrames,result,credits,bet,state,score,msg;
+
+  function pickSym(){
+    const total=WEIGHTS.reduce((a,b)=>a+b,0);
+    let r=rng(total),i=0;
+    for(;i<WEIGHTS.length;i++){r-=WEIGHTS[i];if(r<0)break;}
+    return SYMS[i]??SYMS[0];
+  }
+
+  function start(){
+    reels=[[pickSym(),pickSym(),pickSym()],[pickSym(),pickSym(),pickSym()],[pickSym(),pickSym(),pickSym()]];
+    credits=opts.credits??100; bet=10; spinning=false; spinFrames=0;
+    state='idle'; score=credits; msg='SPACE to spin  +/- adjust bet';
+    em.emit('start');
+  }
+
+  function spin(){
+    if(credits<bet){msg='Not enough credits!';return;}
+    credits-=bet; spinning=true; spinFrames=20; msg='Spinning...';
+  }
+
+  function evalResult(){
+    const r0=reels[0][1],r1=reels[1][1],r2=reels[2][1];
+    const line=r0.trim()+r1.trim()+r2.trim();
+    const key=Object.keys(PAY).find(k=>line.startsWith(k));
+    if(key){const w=PAY[key]*bet/10|0;credits+=w;msg=`${key}! Win ${w}!`;}
+    else if(r0.trim()==='CHR'){credits+=bet/2|0;msg=`Cherry! Win ${bet/2|0}`;}
+    else msg='No win. Try again!';
+    score=credits; em.emit('score',credits);
+    if(credits<=0){state='gameover';em.emit('gameover',0);}
+  }
+
+  function input(key){
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(spinning) return;
+    if(key==='space') spin();
+    if(key==='+'||key==='up')   bet=Math.min(credits,bet+5);
+    if(key==='-'||key==='down') bet=Math.max(5,bet-5);
+    if(key==='enter') spin();
+  }
+
+  function tick(dt=16){
+    if(!spinning) return;
+    spinFrames--;
+    if(spinFrames>0){
+      for(let i=0;i<3;i++){
+        if(spinFrames>(i*5)){
+          reels[i]=[pickSym(),pickSym(),pickSym()];
+        }
+      }
+    } else {
+      spinning=false; evalResult();
+    }
+  }
+
+  function frame(){
+    const W=40,H=14;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` SLOTS  Credits:${credits}  Bet:${bet}  [SPACE spin  +/- bet]`,FC.YEL,BC.blk);
+    // machine frame
+    cv.box(4,2,32,9,FC.WHT,BC.blk);
+    // three reels
+    for(let reel=0;reel<3;reel++){
+      const rx=reel*10+5;
+      for(let row=0;row<3;row++){
+        const sym=reels[reel][row];
+        const idx=SYMS.indexOf(sym);
+        const col=SYM_COL[idx]??FC.wht;
+        const hl=row===1;
+        cv.put(rx,row+3,sym,hl?col:FC.BLK,hl?BC.blk:BC.blk);
+      }
+      if(reel<2) for(let y=3;y<6;y++) cv.set(rx+3,y,'│',FC.BLK,BC.blk);
+    }
+    // payline indicator
+    cv.put(4,4,'►',FC.RED,BC.blk); cv.put(35,4,'◄',FC.RED,BC.blk);
+    cv.put(2,H-3,msg.padEnd(W-4,' '),FC.WHT,BC.blk);
+    if(state==='gameover') cv.put(2,H-2,'  BROKE!  ENTER restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score??credits;} };
+}
+
+// ─── GAME: VIDEO POKER ───────────────────────────────────────────────────────
+
+function makeVideoPoker(opts = {}) {
+  const em=makeEmitter();
+  const SUITS=['♠','♥','♦','♣'],RANKS=['2','3','4','5','6','7','8','9','10','J','Q','K','A'];
+  const SUIT_COL={'♠':FC.WHT,'♥':FC.RED,'♦':FC.RED,'♣':FC.WHT};
+  const HANDS=[
+    ['Royal Flush',800],['Straight Flush',50],['Four of a Kind',25],
+    ['Full House',9],['Flush',6],['Straight',4],
+    ['Three of a Kind',3],['Two Pair',2],['Jacks or Better',1],['Nothing',0],
+  ];
+  let deck,hand,held,credits,bet,state,score,msg,phase;
+
+  function makeDeck(){ return shuffle(SUITS.flatMap(s=>RANKS.map(r=>({r,s})))); }
+  function deal(){ return deck.pop()??makeDeck().pop(); }
+
+  function evalHand(h){
+    const ri=h.map(c=>RANKS.indexOf(c.r)).sort((a,b)=>a-b);
+    const flush=h.every(c=>c.s===h[0].s);
+    const straight=ri.every((v,i)=>i===0||v===ri[i-1]+1)||
+                   (ri.join(',')===('0,1,2,3,12')); // A-2-3-4-5
+    const freq=Object.values(ri.reduce((m,v)=>{m[v]=(m[v]||0)+1;return m;},{})).sort((a,b)=>b-a);
+    const pairs=freq.filter(f=>f===2).length;
+    const hasJackOrBetter=pairs>=1&&h.some(c=>['J','Q','K','A'].includes(c.r)&&
+      h.filter(x=>x.r===c.r).length===2);
+    if(flush&&straight&&ri[4]===12&&ri[0]===8) return 'Royal Flush';
+    if(flush&&straight) return 'Straight Flush';
+    if(freq[0]===4) return 'Four of a Kind';
+    if(freq[0]===3&&freq[1]===2) return 'Full House';
+    if(flush) return 'Flush';
+    if(straight) return 'Straight';
+    if(freq[0]===3) return 'Three of a Kind';
+    if(pairs===2) return 'Two Pair';
+    if(hasJackOrBetter) return 'Jacks or Better';
+    return 'Nothing';
+  }
+
+  function start(){
+    deck=makeDeck(); credits=opts.credits??100; bet=10;
+    hand=[]; held=[false,false,false,false,false];
+    state='idle'; score=credits; msg='ENTER to deal  +/- adjust bet';
+    em.emit('start');
+  }
+
+  function startRound(){
+    if(credits<bet){msg='Not enough credits!';return;}
+    credits-=bet;
+    hand=[deal(),deal(),deal(),deal(),deal()];
+    held=[false,false,false,false,false];
+    phase='hold'; state='playing'; msg='1-5 toggle hold  ENTER draw';
+  }
+
+  function draw(){
+    for(let i=0;i<5;i++) if(!held[i]) hand[i]=deal();
+    const hn=evalHand(hand);
+    const [,mult]=HANDS.find(([n])=>n===hn)??['',0];
+    const win=mult*bet;
+    credits+=win; score=credits; em.emit('score',credits);
+    msg=`${hn}${win?` — Win ${win}!`:''}`;
+    phase='result'; state='roundover';
+    if(credits<=0){state='gameover';em.emit('gameover',0);}
+  }
+
+  function input(key){
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(state==='roundover'&&key==='enter'){state='idle';msg='ENTER to deal  +/- bet';return;}
+    if(state==='idle'){
+      if(key==='+') bet=Math.min(credits,bet+5);
+      if(key==='-') bet=Math.max(5,bet-5);
+      if(key==='enter'||key==='space') startRound();
+      return;
+    }
+    if(state!=='playing') return;
+    if(/^[1-5]$/.test(key)) held[+key-1]=!held[+key-1];
+    if(key==='enter'||key==='space') draw();
+  }
+
+  function frame(){
+    const W=50,H=18;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` VIDEO POKER (Jacks or Better)  Credits:${credits}  Bet:${bet}`,FC.YEL,BC.blk);
+    // paytable
+    const pOx=35;
+    HANDS.forEach(([n,m],i)=>{
+      cv.put(pOx,i+2,`${n}: ${m*bet}`,m?FC.YEL:FC.BLK,BC.blk);
+    });
+    // cards
+    for(let i=0;i<5;i++){
+      const cx2=i*7+1, cy2=3;
+      if(hand[i]){
+        cv.box(cx2,cy2,6,5,FC.wht,BC.blk);
+        cv.put(cx2+1,cy2+1,`${hand[i].r}`,SUIT_COL[hand[i].s],BC.blk);
+        cv.put(cx2+2,cy2+2,`${hand[i].s}`,SUIT_COL[hand[i].s],BC.blk);
+        cv.put(cx2+1,cy2+3,held[i]?'HELD':'    ',held[i]?FC.YEL:FC.BLK,BC.blk);
+      } else {
+        cv.box(cx2,cy2,6,5,FC.BLK,BC.blk);
+      }
+      cv.put(cx2+2,cy2+5,` ${i+1} `,FC.BLK,BC.blk);
+    }
+    cv.put(1,9,msg.padEnd(33,' '),FC.WHT,BC.blk);
+    if(state==='idle') cv.put(1,10,'ENTER to deal',FC.GRN,BC.blk);
+    if(state==='gameover') cv.put(1,10,'  BROKE!  ENTER restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score??credits;} };
+}
+
+// ─── GAME: HANGMAN ───────────────────────────────────────────────────────────
+
+function makeHangman(opts = {}) {
+  const em=makeEmitter();
+  let word,guessed,wrong,state,score;
+
+  const GALLOWS=[
+    ['     ','     ','     ','     ','     ','     ','     '],
+    ['     ','     ','     ','     ','     ','     ','═════'],
+    ['  ╔  ','  ║  ','     ','     ','     ','     ','═════'],
+    ['  ╔══','  ║  ','     ','     ','     ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ','     ','     ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ','  │  ','     ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ',' /│  ','     ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ',' /│\\ ','     ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ',' /│\\ ',' /   ','     ','═════'],
+    ['  ╔══','  ║  ','  ○  ',' /│\\ ',' / \\ ','     ','═════'],
+  ];
+
+  function start(){
+    word=HANGMAN_WORDS[rng(HANGMAN_WORDS.length)].toUpperCase();
+    guessed=new Set(); wrong=0; state='playing'; score=0;
+    em.emit('start');
+  }
+
+  function input(key){
+    if((state==='gameover'||state==='won')&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(/^[a-z]$/.test(key)){
+      const ch=key.toUpperCase();
+      if(guessed.has(ch)) return;
+      guessed.add(ch);
+      if(!word.includes(ch)){
+        wrong++; if(wrong>=9){state='gameover';em.emit('gameover',0);}
+      } else {
+        if([...word].every(c=>guessed.has(c))){
+          score=Math.max(10,(9-wrong)*100); state='won'; em.emit('win',score);
+        }
+      }
+    }
+  }
+
+  function frame(){
+    const W=50,H=14;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` HANGMAN  Wrong:${wrong}/9  [a-z to guess  ENTER restart]`,FC.YEL,BC.blk);
+    // gallows
+    const stage=GALLOWS[Math.min(wrong,9)];
+    for(let i=0;i<stage.length;i++) cv.put(1,i+2,stage[i],FC.wht,BC.blk);
+    // word display
+    const display=[...word].map(c=>guessed.has(c)?c:'_').join(' ');
+    cv.put(10,4,display,FC.CYN,BC.blk);
+    // guessed letters
+    const sorted=[...guessed].sort();
+    cv.put(10,6,`Guessed: ${sorted.join(' ')}`,FC.BLK,BC.blk);
+    if(state==='won')      cv.put(10,8,`  YOU WIN! The word was ${word}  `,FC.WHT,BC.grn);
+    if(state==='gameover') cv.put(10,8,`  GAME OVER! Word: ${word}  `,FC.WHT,BC.red);
+    if(state!=='idle')     cv.put(10,9,`Hint: ${word.length} letters`,FC.BLK,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: TYPING TEST ───────────────────────────────────────────────────────
+
+function makeTypingTest(opts = {}) {
+  const em=makeEmitter();
+  let phrase,typed,startTime,endTime,wpm,accuracy,state,score,phraseIdx;
+
+  function start(){
+    phraseIdx=rng(TYPING_PHRASES.length);
+    phrase=TYPING_PHRASES[phraseIdx];
+    typed=''; startTime=null; endTime=null; wpm=0; accuracy=100;
+    state='playing'; score=0;
+    em.emit('start');
+  }
+
+  function input(key){
+    if((state==='won'||state==='gameover')&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(!startTime) startTime=Date.now();
+    if(key==='backspace'||key==='delete'){ typed=typed.slice(0,-1); return; }
+    if(key.length===1) {
+      typed+=key;
+      if(typed.length===phrase.length){
+        endTime=Date.now();
+        const elapsed=(endTime-startTime)/60000;
+        const words=phrase.split(' ').length;
+        wpm=Math.round(words/elapsed);
+        const correct=[...typed].filter((c,i)=>c===phrase[i]).length;
+        accuracy=Math.round(correct/phrase.length*100);
+        score=wpm*accuracy/100|0;
+        state='won'; em.emit('win',score);
+      }
+    }
+  }
+
+  function frame(){
+    const W=60,H=14;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    const elapsed=startTime?((Date.now()-startTime)/1000).toFixed(1):'0.0';
+    cv.put(0,0,` TYPING TEST  Time:${elapsed}s  WPM:${wpm}  Accuracy:${accuracy}%`,FC.YEL,BC.blk);
+    cv.put(1,2,'Type the phrase below:',FC.CYN,BC.blk);
+    // wrap phrase at 56 chars
+    const wrap=56;
+    let py=4;
+    for(let i=0;i<phrase.length;i+=wrap){
+      const chunk=phrase.slice(i,i+wrap);
+      for(let j=0;j<chunk.length;j++){
+        const gi=i+j;
+        let col=FC.BLK;
+        if(gi<typed.length) col=typed[gi]===phrase[gi]?FC.GRN:FC.RED;
+        cv.set(j+2,py,phrase[gi],col,BC.blk);
+      }
+      // show cursor
+      if(typed.length>=i&&typed.length<i+wrap) cv.set(typed.length-i+2,py,'▌',FC.WHT,BC.blk);
+      py++;
+    }
+    if(state==='won'){
+      cv.put(1,py+1,` Done! WPM:${wpm}  Accuracy:${accuracy}%  Score:${score}  ENTER again `,FC.WHT,BC.grn);
+    } else {
+      cv.put(1,py+1,' [Type above. Backspace to correct]',FC.BLK,BC.blk);
+    }
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: SIMON SAYS ────────────────────────────────────────────────────────
+
+function makeSimon(opts = {}) {
+  const em=makeEmitter();
+  const COLORS=['RED','GRN','BLU','YEL'];
+  const FC_MAP={RED:FC.RED,GRN:FC.GRN,BLU:FC.BLU,YEL:FC.YEL};
+  const BC_MAP={RED:BC.red,GRN:BC.grn,BLU:BC.blu,YEL:BC.yel};
+  let sequence,playerIdx,showIdx,showing,showTimer,state,score,lit,msg,speed;
+
+  function start(){
+    sequence=[COLORS[rng(4)]]; playerIdx=0; showIdx=0; showing=true;
+    showTimer=0; state='playing'; score=0; lit=null; speed=800; msg='Watch...';
+    em.emit('start');
+  }
+
+  function input(key){
+    if(state==='gameover'&&key==='enter'){start();return;}
+    if(state!=='playing'||showing) return;
+    const map={'1':'RED','2':'GRN','3':'BLU','4':'YEL'};
+    const chosen=map[key]; if(!chosen) return;
+    lit=chosen; setTimeout(()=>{lit=null;},200);
+    if(chosen===sequence[playerIdx]){
+      playerIdx++;
+      if(playerIdx===sequence.length){
+        score+=sequence.length; em.emit('score',score);
+        sequence.push(COLORS[rng(4)]); speed=Math.max(300,speed-30);
+        showIdx=0; playerIdx=0; showing=true; msg='Watch...';
+      }
+    } else {
+      state='gameover'; msg=`Wrong! The sequence was: ${sequence.join(' ')}`; em.emit('gameover',score);
+    }
+  }
+
+  function tick(dt=16){
+    if(state!=='playing'||!showing) return;
+    showTimer+=dt;
+    if(showTimer>=speed){
+      showTimer=0; lit=null;
+      if(showIdx<sequence.length){
+        lit=sequence[showIdx]; showIdx++;
+      } else {
+        showing=false; lit=null; msg=`Round ${score/sequence.length+1}! Press 1-4`;
+      }
+    } else if(showTimer<speed*0.6){
+      if(showIdx>0&&showIdx<=sequence.length) lit=sequence[showIdx-1];
+    } else {
+      lit=null;
+    }
+  }
+
+  function frame(){
+    const W=40,H=18;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` SIMON SAYS  Round:${sequence.length}  Score:${score}`,FC.YEL,BC.blk);
+    // 4 color pads: 2×2 layout
+    const pads=[['RED',1,2],['GRN',21,2],['BLU',1,10],['YEL',21,10]];
+    const labels=[['RED','[1]'],['GRN','[2]'],['BLU','[3]'],['YEL','[4]']];
+    for(let i=0;i<4;i++){
+      const [col,ox,oy]=pads[i];
+      const active=lit===col;
+      const fc=active?FC.WHT:FC_MAP[col];
+      const bc=active?BC_MAP[col]:BC.blk;
+      cv.fill(ox,oy,16,6,' ',fc,bc);
+      cv.put(ox+5,oy+2,`  ${col}  `,fc,bc);
+      cv.put(ox+5,oy+3,`  ${labels[i][1]}  `,fc,bc);
+    }
+    cv.put(1,H-3,msg.padEnd(W-2,' '),FC.WHT,BC.blk);
+    if(state==='gameover') cv.put(1,H-2,'  GAME OVER  ENTER restart  ',FC.WHT,BC.red);
+    return cv.render();
+  }
+
+  return { start, input, tick, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: ROCK PAPER SCISSORS LIZARD SPOCK ─────────────────────────────────
+
+function makeRockPaperScissors(opts = {}) {
+  const em=makeEmitter();
+  const CHOICES=['Rock','Paper','Scissors','Lizard','Spock'];
+  const BEATS={
+    Rock:['Scissors','Lizard'], Paper:['Rock','Spock'],
+    Scissors:['Paper','Lizard'], Lizard:['Spock','Paper'], Spock:['Rock','Scissors'],
+  };
+  const VERBS={
+    'Rock-Scissors':'crushes','Rock-Lizard':'crushes',
+    'Paper-Rock':'covers','Paper-Spock':'disproves',
+    'Scissors-Paper':'cuts','Scissors-Lizard':'decapitates',
+    'Lizard-Spock':'poisons','Lizard-Paper':'eats',
+    'Spock-Rock':'vaporizes','Spock-Scissors':'smashes',
+  };
+  let curIdx,stats,state,score,msg,lastResult;
+
+  function start(){
+    curIdx=0; stats={wins:0,losses:0,draws:0};
+    state='playing'; score=0; msg='Choose your weapon!'; lastResult=null;
+    em.emit('start');
+  }
+
+  function play(choice){
+    const ai=CHOICES[rng(5)];
+    if(choice===ai){ stats.draws++; msg=`DRAW! Both chose ${choice}.`; }
+    else if(BEATS[choice].includes(ai)){
+      stats.wins++; score+=10; em.emit('score',score);
+      const verb=VERBS[`${choice}-${ai}`]??'beats';
+      msg=`WIN! ${choice} ${verb} ${ai}!`;
+    } else {
+      stats.losses++;
+      const verb=VERBS[`${ai}-${choice}`]??'beats';
+      msg=`LOSE! ${ai} ${verb} ${choice}.`;
+    }
+    lastResult={choice,ai};
+  }
+
+  function input(key){
+    if(state!=='playing') return;
+    if(key==='left')  curIdx=(curIdx-1+CHOICES.length)%CHOICES.length;
+    if(key==='right') curIdx=(curIdx+1)%CHOICES.length;
+    if(key==='enter'||key==='space') play(CHOICES[curIdx]);
+    // shortcuts
+    const shortcuts={r:0,p:1,s:2,l:3,v:4};
+    if(shortcuts[key]!==undefined){ curIdx=shortcuts[key]; play(CHOICES[curIdx]); }
+  }
+
+  function frame(){
+    const W=50,H=16;
+    const cv=makeCanvas(W,H); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` RPS-LS  Score:${score}  W:${stats.wins} L:${stats.losses} D:${stats.draws}`,FC.YEL,BC.blk);
+    cv.put(1,2,'Rock  Paper  Scissors  Lizard  Spock',FC.BLK,BC.blk);
+    cv.put(1,3,'[R]   [P]   [S]        [L]    [V]',FC.BLK,BC.blk);
+    // selector
+    const offsets=[0,6,13,23,30];
+    cv.put(offsets[curIdx]+1,2,CHOICES[curIdx],FC.CYN,BC.blk);
+    cv.put(offsets[curIdx]+1,4,'▲',FC.YEL,BC.blk);
+    // icons
+    const ICONS=['🪨','📄','✂️','🦎','🖖'];
+    const txts=['Rock ','Paper','Sciss','Lizrd','Spock'];
+    cv.put(1,5,'[←→ select  ENTER choose  or R/P/S/L/V]',FC.BLK,BC.blk);
+    if(msg) cv.put(1,7,msg.padEnd(W-2,' '),FC.WHT,BC.blk);
+    if(lastResult){
+      cv.put(1,9,`You: ${lastResult.choice.padEnd(10,' ')}   AI: ${lastResult.ai}`,FC.CYN,BC.blk);
+    }
+    cv.put(1,11,'Win conditions:',FC.BLK,BC.blk);
+    cv.put(1,12,'Rock crushes Scissors/Lizard',FC.BLK,BC.blk);
+    cv.put(1,13,'Paper covers Rock, disproves Spock',FC.BLK,BC.blk);
+    cv.put(1,14,'Scissors cuts Paper, decapitates Lizard',FC.BLK,BC.blk);
+    cv.put(1,15,'Lizard poisons Spock, eats Paper',FC.BLK,BC.blk);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: DUNGEON CRAWLER ───────────────────────────────────────────────────
+
+function makeDungeon(opts = {}) {
+  const em=makeEmitter();
+  const W=5, H=4; // room grid
+  const MONSTERS=[
+    {name:'Slime',hp:8,atk:2,xp:15,gold:5},
+    {name:'Goblin',hp:14,atk:4,xp:25,gold:10},
+    {name:'Orc',hp:22,atk:6,xp:40,gold:20},
+    {name:'Troll',hp:35,atk:8,xp:60,gold:35},
+    {name:'Dragon',hp:60,atk:12,xp:120,gold:80},
+  ];
+  const ITEMS=[
+    {name:'Health Potion',effect:'heal',val:20,cost:15},
+    {name:'Sword',effect:'atk',val:3,cost:30},
+    {name:'Shield',effect:'def',val:2,cost:25},
+    {name:'Elixir',effect:'heal',val:50,cost:40},
+  ];
+  let rooms,px,py,player,combat,state,score,msg,log;
+
+  function makeRooms(){
+    const types=['empty','empty','empty','monster','monster','monster','monster','treasure','shop','boss'];
+    const shuffled=shuffle(types);
+    const grid=Array.from({length:H},(_,r)=>Array.from({length:W},(_,c)=>{
+      const idx=r*W+c;
+      if(r===0&&c===0) return {type:'empty',visited:false,cleared:true,monster:null,item:null};
+      const t=shuffled[idx%shuffled.length];
+      let monster=null, item=null;
+      if(t==='monster'||t==='boss'){
+        const mi=t==='boss'?4:rng(4);
+        monster={...MONSTERS[mi],maxHp:MONSTERS[mi].hp,hp:MONSTERS[mi].hp};
+      }
+      if(t==='treasure') item=ITEMS[rng(ITEMS.length)];
+      return {type:t,visited:false,cleared:t==='empty',monster,item};
+    }));
+    // place exit at bottom-right
+    grid[H-1][W-1]={type:'exit',visited:false,cleared:true};
+    return grid;
+  }
+
+  function start(){
+    rooms=makeRooms(); px=0; py=0; rooms[0][0].visited=true;
+    player={hp:30,maxHp:30,atk:5,def:2,level:1,xp:0,xpNext:100,gold:20,inv:[]};
+    combat=null; state='playing'; score=0; log=[]; msg='Find the exit ★!';
+    em.emit('start');
+  }
+
+  function addLog(s){ log.unshift(s); if(log.length>5) log.pop(); }
+
+  function enterRoom(){
+    const room=rooms[py][px];
+    room.visited=true;
+    if(room.type==='exit'){ score=player.gold+player.xp; state='won'; em.emit('win',score); return; }
+    if(room.type==='treasure'&&room.item&&!room.cleared){
+      const it=room.item;
+      player.inv.push(it.name);
+      if(it.effect==='heal') player.hp=Math.min(player.maxHp,player.hp+it.val);
+      if(it.effect==='atk')  player.atk+=it.val;
+      if(it.effect==='def')  player.def+=it.val;
+      addLog(`Found ${it.name}!`); room.cleared=true; return;
+    }
+    if((room.type==='monster'||room.type==='boss')&&room.monster&&!room.cleared){
+      combat={...room.monster}; msg=`Fighting ${combat.name}! A=attack F=flee`;
+    }
+  }
+
+  function attackRound(flee=false){
+    if(!combat) return;
+    if(flee){
+      if(Math.random()<0.4){
+        combat=null; px=clamp(px+(rng(2)?1:-1),0,W-1); py=clamp(py+(rng(2)?1:-1),0,H-1);
+        addLog('Fled!'); return;
+      } else { addLog('Couldn\'t flee!'); }
+    }
+    // player attacks
+    const pdmg=Math.max(1,(Math.random()*player.atk|0)+1);
+    combat.hp-=pdmg; addLog(`Hit ${combat.name} for ${pdmg}`);
+    if(combat.hp<=0){
+      const room=rooms[py][px];
+      room.cleared=true; room.monster=null;
+      player.xp+=combat.xp; player.gold+=combat.gold;
+      addLog(`${combat.name} defeated! +${combat.xp}xp +${combat.gold}g`);
+      while(player.xp>=player.xpNext){
+        player.xp-=player.xpNext; player.level++; player.xpNext=player.level*100;
+        player.atk+=2; player.def+=1; player.maxHp+=10; player.hp=player.maxHp;
+        addLog(`Level up! Now level ${player.level}`);
+      }
+      combat=null; msg='Room cleared!'; return;
+    }
+    // monster attacks
+    const mdmg=Math.max(1,(Math.random()*combat.atk|0)+1-player.def);
+    player.hp-=mdmg; addLog(`${combat.name} hits you for ${mdmg}`);
+    if(player.hp<=0){ player.hp=0; state='gameover'; em.emit('gameover',score); msg='You died!'; combat=null; }
+  }
+
+  function usePotion(){
+    const idx=player.inv.indexOf('Health Potion');
+    if(idx<0){ addLog('No potions!'); return; }
+    player.inv.splice(idx,1);
+    player.hp=Math.min(player.maxHp,player.hp+20);
+    addLog('Used Health Potion +20 HP');
+  }
+
+  function input(key){
+    if((state==='gameover'||state==='won')&&key==='enter'){start();return;}
+    if(state!=='playing') return;
+    if(combat){
+      if(key==='a'||key==='space') attackRound(false);
+      if(key==='f')                attackRound(true);
+      if(key==='p')                usePotion();
+      return;
+    }
+    let moved=false;
+    if(key==='up'   &&py>0)   { py--; moved=true; }
+    if(key==='down' &&py<H-1) { py++; moved=true; }
+    if(key==='left' &&px>0)   { px--; moved=true; }
+    if(key==='right'&&px<W-1) { px++; moved=true; }
+    if(moved) enterRoom();
+    if(key==='p') usePotion();
+  }
+
+  function frame(){
+    const CW=W*6+4,CH=H*4+2, totalW=CW+30, totalH=Math.max(CH,18)+3;
+    const cv=makeCanvas(totalW,totalH); cv.clear(' ',FC.wht,BC.blk);
+    cv.put(0,0,` DUNGEON  Level:${player.level}  Gold:${player.gold}  XP:${player.xp}/${player.xpNext}`,FC.YEL,BC.blk);
+    // map
+    const icons={empty:' ',monster:'M',boss:'B',treasure:'T',shop:'$',exit:'★'};
+    const icols={empty:FC.BLK,monster:FC.RED,boss:FC.RED,treasure:FC.YEL,shop:FC.GRN,exit:FC.GRN};
+    for(let r=0;r<H;r++) for(let c=0;c<W;c++){
+      const room=rooms[r][c];
+      const isHere=c===px&&r===py;
+      const bx=c*6+1, by=r*4+2;
+      cv.box(bx,by,5,3,isHere?FC.YEL:FC.BLK,BC.blk);
+      if(room.visited){
+        const ic=room.cleared?icons[room.type]??'?':icons[room.type]??'?';
+        const col=room.cleared&&room.type!=='exit'?FC.BLK:icols[room.type]??FC.wht;
+        cv.set(bx+2,by+1,isHere?'@':ic,isHere?FC.YEL:col,BC.blk);
+      } else {
+        cv.set(bx+2,by+1,'?',FC.BLK,BC.blk);
+      }
+    }
+    // stats
+    const sx=CW+2;
+    cv.put(sx,2, `HP: ${player.hp}/${player.maxHp}`,player.hp<10?FC.RED:FC.GRN,BC.blk);
+    cv.put(sx,3, `ATK:${player.atk}  DEF:${player.def}`,FC.CYN,BC.blk);
+    cv.put(sx,4, `Inv: ${player.inv.slice(0,3).join(', ')||'empty'}`,FC.wht,BC.blk);
+    cv.put(sx,6, 'LOG:',FC.BLK,BC.blk);
+    for(let i=0;i<Math.min(log.length,5);i++) cv.put(sx,7+i,log[i].slice(0,24),FC.wht,BC.blk);
+    // combat
+    if(combat){
+      cv.put(sx,13,`COMBAT: ${combat.name}`,FC.RED,BC.blk);
+      cv.put(sx,14,`Enemy HP: ${combat.hp}/${combat.maxHp}`,FC.RED,BC.blk);
+      cv.put(sx,15,'A=attack F=flee P=potion',FC.YEL,BC.blk);
+    } else {
+      cv.put(sx,13,'[Arrows move  P=potion]',FC.BLK,BC.blk);
+      cv.put(sx,14,msg.slice(0,24),FC.wht,BC.blk);
+    }
+    cv.put(0,totalH-1,'  M=Monster T=Treasure $=Shop ★=Exit  ',FC.BLK,BC.blk);
+    if(state==='gameover') cv.put(sx,16,'  DEAD  ENTER restart  ',FC.WHT,BC.red);
+    if(state==='won')      cv.put(sx,16,`  ESCAPED! Score:${score}  ENTER again  `,FC.WHT,BC.grn);
+    return cv.render();
+  }
+
+  return { start, input, tick(){}, frame,
+    on:em.on.bind(em), off:em.off.bind(em),
+    get state(){return state;}, get score(){return score;} };
+}
+
+// ─── GAME: LEARNING CHATBOT ──────────────────────────────────────────────────
+
+function makeLearningChatbot(opts = {}) {
+  const em=makeEmitter();
+
+  const SLANG_SET=new Set(['lol','lmao','lmfao','omg','ngl','tbh','imo','idk','bruh','fr','nah','yea','ye','sus','vibes','slay','lowkey','highkey','based','cringe','bussin','no cap','deadass','bet','fire','snatched','rent free','understood the assignment','it hits different',
+    'main character','no printer','say less','big yikes','ick','rizz','simp','NPC',
+    'W','L','ratio','mid','slaps','hits different','touch grass','ate that']);
+
+  const FORMAL_MAP={
+    'lol':'haha','lmao':'haha','lmfao':'haha','omg':'oh my','ngl':'honestly',
+    'tbh':'to be honest','imo':'in my opinion','idk':'I don\'t know','bruh':'come on',
+    'fr':'for real','nah':'no','yea':'yes','ye':'yes','sus':'suspicious',
+    'bet':'okay','W':'win','L':'loss','mid':'mediocre','rizz':'charm',
+    'simp':'someone who is overly devoted','NPC':'background character',
+    'ratio':'when a reply gets more likes than the original post',
+    'no cap':'no lie','deadass':'seriously','bussin':'delicious',
+    'slay':'do something excellently','lowkey':'somewhat secretly',
+    'highkey':'very openly','based':'confident and unapologetically yourself',
+    'cringe':'embarrassing','vibes':'atmosphere or feeling',
+    'touch grass':'go outside and engage with real life',
+    'understood the assignment':'performed perfectly',
+    'it hits different':'feels uniquely special',
+    'main character':'acts like they\'re the protagonist of life',
+    'rent free':'occupying your thoughts without effort',
+    'fire':'amazing','snatched':'looking great','ick':'sudden repulsion',
+    'say less':'understood, no more needs to be said',
+    'big yikes':'that\'s very unfortunate','slaps':'is really good',
+    'ate that':'did something perfectly',
+  };
+
+  // conversation state
+  let msgs, learnQueue, score, state, inputBuf, mode;
+  // mode: 'chat' | 'quiz'
+  let quizWord, quizAnswer, quizStreak;
+
+  function start() {
+    msgs = [
+      { from:'bot', text:'Hey! I\'m SlangBot. I learn new slang from you and quiz you on it.' },
+      { from:'bot', text:'Chat normally — I\'ll flag words I don\'t recognize. Type /quiz to test yourself, /list to see what I know.' },
+    ];
+    learnQueue = []; score = 0; state = 'playing'; inputBuf = ''; mode = 'chat';
+    quizWord = null; quizAnswer = null; quizStreak = 0;
+    em.emit('start');
+  }
+
+  function botReply(text) { msgs.push({ from:'bot', text }); if (msgs.length > 30) msgs.shift(); }
+  function userMsg(text)  { msgs.push({ from:'usr', text }); if (msgs.length > 30) msgs.shift(); }
+
+  function tokenize(s) { return s.toLowerCase().match(/[a-z']+/g) ?? []; }
+
+  function processChat(line) {
+    const words = tokenize(line);
+    const unknown = words.filter(w => !SLANG_SET.has(w) && !FORMAL_MAP[w] && w.length > 2 &&
+      !['the','and','but','for','you','are','was','not','that','this','with','have',
+        'from','they','will','been','just','when','what','your','can','its','him',
+        'her','had','his','has','she','did','how','all','one','out','who','get',
+        'use','say','way','may','see','now','our','any','new','two','day','got',
+        'let','put','man','too','old','why','did','few','off','set','own','run',
+        'ive','im','its','id','dont','cant','wont','isnt','arent','wasnt',
+        'shouldnt','wouldnt','couldnt','aint'].includes(w));
+
+    // translate known slang
+    const translated = words.map(w => FORMAL_MAP[w] ? `${FORMAL_MAP[w]}` : w).join(' ');
+    const hasSlang = words.some(w => SLANG_SET.has(w) || FORMAL_MAP[w]);
+
+    if (hasSlang) {
+      botReply(`Decoded: "${translated}"`);
+    }
+
+    if (unknown.length > 0) {
+      learnQueue.push(...unknown);
+      botReply(`Hmm, I don't know: ${unknown.map(w=>`"${w}"`).join(', ')}. What do they mean? (type: word = meaning)`);
+    } else if (!hasSlang) {
+      // generic responses
+      const responses = [
+        'Interesting! Tell me more.',
+        'Got it. Drop some slang and I\'ll decode it.',
+        'Cool. Try /quiz to test your slang knowledge.',
+        'Noted! I\'m always learning.',
+      ];
+      botReply(responses[msgs.length % responses.length]);
+    }
+  }
+
+  function processDefinition(line) {
+    // format: word = meaning  OR  word: meaning
+    const m = line.match(/^([a-z'\s]+?)\s*[=:]\s*(.+)$/i);
+    if (!m) { botReply('Try: word = meaning'); return; }
+    const word = m[1].trim().toLowerCase();
+    const meaning = m[2].trim();
+    if (FORMAL_MAP[word]) {
+      botReply(`I already know "${word}" means "${FORMAL_MAP[word]}"!`);
+      return;
+    }
+    FORMAL_MAP[word] = meaning;
+    SLANG_SET.add(word);
+    learnQueue = learnQueue.filter(w => w !== word);
+    score += 5; em.emit('score', score);
+    botReply(`Learned! "${word}" = "${meaning}" ✓ (+5 points)`);
+  }
+
+  function startQuiz() {
+    const known = Object.keys(FORMAL_MAP);
+    if (known.length < 3) { botReply('I need to know at least 3 words first. Chat with me!'); return; }
+    quizWord = known[rng(known.length)];
+    quizAnswer = FORMAL_MAP[quizWord];
+    mode = 'quiz';
+    botReply(`QUIZ TIME! What does "${quizWord}" mean? (type your answer)`);
+  }
+
+  function checkQuiz(line) {
+    const ans = line.toLowerCase().trim();
+    const correct = quizAnswer.toLowerCase();
+    // fuzzy: share 2+ words or substring
+    const aWords = new Set(ans.split(/\s+/));
+    const cWords = correct.split(/\s+/);
+    const overlap = cWords.filter(w => aWords.has(w) || ans.includes(w)).length;
+    const pass = overlap >= 1 || ans.includes(correct.slice(0,5));
+    if (pass) {
+      quizStreak++; score += 10 * quizStreak; em.emit('score', score);
+      botReply(`✓ Correct! "${quizWord}" = "${quizAnswer}". Streak: ${quizStreak}x! (+${10*quizStreak}pts)`);
+    } else {
+      quizStreak = 0;
+      botReply(`✗ Nope! "${quizWord}" means "${quizAnswer}". Streak reset.`);
+    }
+    mode = 'chat'; quizWord = null;
+  }
+
+  function input(key) {
+    if (state !== 'playing') { if (key === 'enter') start(); return; }
+    if (key === 'enter') {
+      const line = inputBuf.trim(); inputBuf = '';
+      if (!line) return;
+      userMsg(line);
+      const lower = line.toLowerCase();
+      if (mode === 'quiz') { checkQuiz(line); return; }
+      if (lower === '/quiz')  { startQuiz(); return; }
+      if (lower === '/list')  {
+        const known = Object.keys(FORMAL_MAP);
+        botReply(`I know ${known.length} words: ${known.slice(-8).join(', ')}${known.length>8?' …':''}`)
+        return;
+      }
+      if (lower === '/reset') { botReply('Starting fresh!'); start(); return; }
+      if (line.match(/^[a-z'\s]+\s*[=:]\s*.+$/i) && learnQueue.length > 0) {
+        processDefinition(line);
+      } else {
+        processChat(line);
+      }
+    } else if (key === 'backspace' || key === 'delete') {
+      inputBuf = inputBuf.slice(0, -1);
+    } else if (key.length === 1) {
+      if (inputBuf.length < 58) inputBuf += key;
+    }
+  }
+
+  function frame() {
+    const W = 62, H = 22;
+    const cv = makeCanvas(W, H); cv.clear(' ', FC.wht, BC.blk);
+    cv.put(0, 0, ` SLANGBOT  Score:${score}  Streak:${quizStreak}x  /quiz /list /reset`, FC.YEL, BC.blk);
+    cv.put(0, 1, '─'.repeat(W), FC.BLK, BC.blk);
+    // messages
+    const visible = msgs.slice(-16);
+    for (let i = 0; i < visible.length; i++) {
+      const m = visible[i];
+      const isBot = m.from === 'bot';
+      const prefix = isBot ? 'BOT: ' : 'YOU: ';
+      const col = isBot ? FC.CYN : FC.GRN;
+      const text = (prefix + m.text).slice(0, W - 1);
+      cv.put(0, i + 2, text, col, BC.blk);
+    }
+    // input line
+    cv.put(0, H - 2, '─'.repeat(W), FC.BLK, BC.blk);
+    const prompt = `> ${inputBuf}${Math.floor(Date.now()/500)%2===0?'▌':' '}`;
+    cv.put(0, H - 1, prompt.padEnd(W, ' '), FC.WHT, BC.blk);
+    if (mode === 'quiz') cv.put(W - 12, 0, ' [QUIZ] ', FC.WHT, BC.red);
+    return cv.render();
+  }
+
+  return {
+    start, input, tick() {}, frame,
+    on: em.on.bind(em), off: em.off.bind(em),
+    get state() { return state; }, get score() { return score; },
+  };
+}
+
+'use strict';
+
+/**
+ * RunGame(game)
+ *
+ * Drives any kitarcade-compatible game object.
+ * Handles: raw stdin key parsing, tick loop, frame rendering, clean exit.
+ *
+ * Usage:
+ *   RunGame(kitdef.Snake());
+ *
+ *   // or pass a factory and let RunGame call it:
+ *   RunGame(Tetris);
+ */
+
+function RunGame(game) {
+  // accept either a live game object or a factory function
+  if (typeof game === 'function') game = game();
+
+  const FPS      = 30;
+  const INTERVAL = 1000 / FPS;
+
+  // ── terminal setup ────────────────────────────────────────────────────────
+
+  const { stdin, stdout } = process;
+
+  function hideCursor()  { stdout.write('\x1b[?25l'); }
+  function showCursor()  { stdout.write('\x1b[?25h'); }
+  function clearScreen() { stdout.write('\x1b[2J\x1b[H'); }
+  function home()        { stdout.write('\x1b[H'); }
+  function altScreen()   { stdout.write('\x1b[?1049h'); }
+  function mainScreen()  { stdout.write('\x1b[?1049l'); }
+
+  // ── cleanup / exit ────────────────────────────────────────────────────────
+
+  let exiting = false;
+
+  function exit(code = 0) {
+    if (exiting) return;
+    exiting = true;
+    clearInterval(tickTimer);
+    if (stdin.isTTY) {
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+    showCursor();
+    mainScreen();
+    process.exit(code);
+  }
+
+  // ── key parsing ───────────────────────────────────────────────────────────
+
+  // Maps raw terminal bytes → game key names
+  const KEY_MAP = {
+    '\x1b[A': 'up',
+    '\x1b[B': 'down',
+    '\x1b[C': 'right',
+    '\x1b[D': 'left',
+    '\x1b[1;2A': 'up',    // shift-up (some terms)
+    '\x1b[1;2B': 'down',
+    '\x1b[1;2C': 'right',
+    '\x1b[1;2D': 'left',
+    '\x1bOA': 'up',       // application cursor keys
+    '\x1bOB': 'down',
+    '\x1bOC': 'right',
+    '\x1bOD': 'left',
+    '\r':     'enter',
+    '\n':     'enter',
+    ' ':      'space',
+    '\t':     'tab',
+    '\x1b':   'escape',
+    '\x7f':   'backspace',
+    '\x08':   'backspace',
+    '\x1b[3~':'delete',
+  };
+
+  function parseKey(buf) {
+    const s = buf.toString();
+    if (KEY_MAP[s]) return KEY_MAP[s];
+    // single printable ASCII
+    if (s.length === 1 && s >= ' ' && s <= '~') return s.toLowerCase();
+    // ctrl-c / ctrl-d → exit
+    if (s === '\x03' || s === '\x04') { exit(0); return null; }
+    return null;
+  }
+
+  // ── render ────────────────────────────────────────────────────────────────
+
+  let lastFrame = '';
+
+  function render() {
+    const f = game.frame();
+    // only redraw if output changed (avoids flicker on idle games)
+    if (f === lastFrame) return;
+    lastFrame = f;
+    home();
+    stdout.write(f);
+    // clear any leftover lines below the frame
+    stdout.write('\x1b[J');
+  }
+
+  // ── tick loop ─────────────────────────────────────────────────────────────
+
+  let prev = Date.now();
+  const tickTimer = setInterval(() => {
+    const now  = Date.now();
+    const dt   = now - prev;
+    prev       = now;
+    game.tick(dt);
+    render();
+  }, INTERVAL);
+
+  // ── stdin ─────────────────────────────────────────────────────────────────
+
+  if (stdin.isTTY) {
+    stdin.setRawMode(true);
+  } else {
+    // piped / non-TTY: still work, just no raw keys
+    process.stderr.write('[RunGame] stdin is not a TTY — keyboard input unavailable\n');
+  }
+
+  stdin.resume();
+  stdin.on('data', (buf) => {
+    const key = parseKey(buf);
+    if (key === null) return;
+    game.input(key);
+    // immediate render on input so the game feels responsive
+    render();
+  });
+
+  // ── game events ───────────────────────────────────────────────────────────
+
+  game.on('gameover', (score) => {
+    render(); // show gameover frame
+    // don't auto-exit — player can press ENTER to restart per game convention
+  });
+
+  game.on('win', (score) => {
+    render();
+  });
+
+  // ── go ────────────────────────────────────────────────────────────────────
+
+  altScreen();
+  hideCursor();
+  clearScreen();
+  render();
+
+  // handle process signals
+  process.on('SIGINT',  () => exit(0));
+  process.on('SIGTERM', () => exit(0));
+  process.on('exit',    ()  => { showCursor(); mainScreen(); });
+
+  // return a handle in case the caller wants to stop it programmatically
+  return {
+    stop: () => exit(0),
+    game,
+  };
+}
+
+// ─── EXPORT ──────────────────────────────────────────────────────────────────
+
+const kitdef = {
+  Snake:            (opts) => { const g = makeSnake(opts);          g.start(); return g; },
+  Tetris:           (opts) => { const g = makeTetris(opts);         g.start(); return g; },
+  DinoRun:          (opts) => { const g = makeDinoRun(opts);        g.start(); return g; },
+  Breakout:         (opts) => { const g = makeBreakout(opts);       g.start(); return g; },
+  SpaceInvaders:    (opts) => { const g = makeSpaceInvaders(opts);  g.start(); return g; },
+  FlappyBird:       (opts) => { const g = makeFlappyBird(opts);     g.start(); return g; },
+  Asteroids:        (opts) => { const g = makeAsteroids(opts);      g.start(); return g; },
+  TwentyFortyEight: (opts) => { const g = makeTwentyFortyEight(opts); g.start(); return g; },
+  Minesweeper:      (opts) => { const g = makeMinesweeper(opts);    g.start(); return g; },
+  Wordle:           (opts) => { const g = makeWordle(opts);         g.start(); return g; },
+  ConnectFour:      (opts) => { const g = makeConnectFour(opts);    g.start(); return g; },
+  Battleship:       (opts) => { const g = makeBattleship(opts);     g.start(); return g; },
+  Maze:             (opts) => { const g = makeMaze(opts);           g.start(); return g; },
+  LightsOut:        (opts) => { const g = makeLightsOut(opts);      g.start(); return g; },
+  Sudoku:           (opts) => { const g = makeSudoku(opts);         g.start(); return g; },
+  Blackjack:        (opts) => { const g = makeBlackjack(opts);      g.start(); return g; },
+  Slots:            (opts) => { const g = makeSlots(opts);          g.start(); return g; },
+  VideoPoker:       (opts) => { const g = makeVideoPoker(opts);     g.start(); return g; },
+  Hangman:          (opts) => { const g = makeHangman(opts);        g.start(); return g; },
+  TypingTest:       (opts) => { const g = makeTypingTest(opts);     g.start(); return g; },
+  Simon:            (opts) => { const g = makeSimon(opts);          g.start(); return g; },
+  RockPaperScissors:(opts) => { const g = makeRockPaperScissors(opts); g.start(); return g; },
+  Dungeon:          (opts) => { const g = makeDungeon(opts);        g.start(); return g; },
+  SlangBot:         (opts) => { const g = makeLearningChatbot(opts); g.start(); return g; },
+  RunGame, // export the runner too, in case someone wants to use it directly
+
+  // list all available game names
+  games: [
+    'Snake','Tetris','DinoRun','Breakout','SpaceInvaders','FlappyBird',
+    'Asteroids','TwentyFortyEight','Minesweeper','Wordle','ConnectFour',
+    'Battleship','Maze','LightsOut','Sudoku','Blackjack','Slots','VideoPoker',
+    'Hangman','TypingTest','Simon','RockPaperScissors','Dungeon','SlangBot',
+  ],
+};
+
+module.exports = { kitdef };