@leafarcade/cli 0.7.0 → 0.8.0

package/dist/cli.mjs

@@ -3735,6 +3735,26 @@ function checkerMoves(s) {
   return moves.some((m) => m.capture !== null) ? moves.filter((m) => m.capture !== null) : moves;
 }
 
+// lib/multiplayer/room-last-move.ts
+function checkerLastMove(history) {
+  const [before, after] = history.slice(-2).map((key2) => key2.split(":")[0].split(",").map(Number));
+  if (!before || !after || before.length !== after.length) return null;
+  const to = after.findIndex((p, i) => p !== 0 && before[i] === 0);
+  if (to < 0) return null;
+  const from = before.findIndex((p, i) => p !== 0 && after[i] === 0 && Math.abs(p) === Math.abs(after[to]));
+  return from < 0 ? null : { from, to };
+}
+function asianLastMove(history) {
+  const [before, after] = history.slice(-2);
+  if (!before || !after || after.mover < 0) return null;
+  const cells = (key2) => key2.split(":")[1]?.split(",") ?? [];
+  const a = cells(before.key), b = cells(after.key), mine = String(after.mover);
+  const to = b.findIndex((cell, i) => cell.startsWith(mine) && cell !== a[i]);
+  if (to < 0) return null;
+  const from = a.findIndex((cell, i) => cell.startsWith(mine) && !b[i].startsWith(mine));
+  return { from: from < 0 ? null : from, to };
+}
+
 // lib/random.ts
 function randomStep(seed) {
   const next3 = seed + 1831565813 >>> 0;
@@ -3767,180 +3787,736 @@ function shuffled(items, entropy2) {
 function index(value, length) {
   return Number.isInteger(value) && value >= 0 && value < length;
 }
-function best(scores) {
-  const high = Math.max(...scores), winners = scores.flatMap((s, i) => s === high ? [i] : []);
+function best(scores2) {
+  const high = Math.max(...scores2), winners = scores2.flatMap((s, i) => s === high ? [i] : []);
   return winners.length === 1 ? winners[0] : null;
 }
 
-// lib/multiplayer/oware.ts
-var side = (at) => at < 6 ? 0 : 1;
-function sow(pits, at) {
-  const board = [...pits];
-  let seeds = board[at], last = at;
-  board[at] = 0;
-  while (seeds > 0) {
-    last = (last + 1) % 12;
-    if (last !== at) {
-      board[last]++;
-      seeds--;
-    }
-  }
-  return { board, last };
+// lib/multiplayer/mills.ts
+var millLines = [
+  [0, 1, 2],
+  [2, 3, 4],
+  [4, 5, 6],
+  [6, 7, 0],
+  [8, 9, 10],
+  [10, 11, 12],
+  [12, 13, 14],
+  [14, 15, 8],
+  [16, 17, 18],
+  [18, 19, 20],
+  [20, 21, 22],
+  [22, 23, 16],
+  [1, 9, 17],
+  [3, 11, 19],
+  [5, 13, 21],
+  [7, 15, 23]
+];
+var millEdges = millLines.flatMap(([a, b, c]) => [
+  [a, b],
+  [b, c]
+]);
+function createMills() {
+  return {
+    board: Array(24).fill(0),
+    reserves: [9, 9],
+    turn: 0,
+    captures: 0,
+    winner: null,
+    draw: false,
+    history: []
+  };
 }
-function owareMoves(s) {
-  if (s.finished) return [];
-  const opponentEmpty = s.pits.every((n, i) => side(i) === s.turn || n === 0);
-  return s.pits.flatMap(
-    (n, at) => n > 0 && side(at) === s.turn && (!opponentEmpty || sow(s.pits, at).board.some((n2, i) => side(i) !== s.turn && n2 > 0)) ? [at] : []
+var linesAt = (board, at) => millLines.filter(
+  (line) => line.includes(at) && line.every((i) => board[i] === board[at])
+);
+function millCaptures(s) {
+  const opponents = s.board.flatMap((p, i) => p === 2 - s.turn ? [i] : []), loose = opponents.filter((at) => !linesAt(s.board, at).length);
+  return loose.length ? loose : opponents;
+}
+function millMoves(s) {
+  if (s.winner !== null || s.draw || s.captures) return [];
+  const empty = s.board.flatMap((p, i) => !p ? [i] : []);
+  if (s.reserves[s.turn]) return empty.map((to) => ({ from: null, to }));
+  const own = s.board.flatMap((p, i) => p === s.turn + 1 ? [i] : []);
+  return own.flatMap(
+    (from) => empty.filter(
+      (to) => own.length === 3 || millEdges.some(
+        ([a, b]) => a === from && b === to || b === from && a === to
+      )
+    ).map((to) => ({ from, to }))
+  );
+}
+function finishTurn(s) {
+  const turn = s.turn === 0 ? 1 : 0, key2 = s.board.join(",") + ":" + turn + ":" + s.reserves.join(",");
+  const next3 = {
+    ...s,
+    turn,
+    captures: 0,
+    history: [...s.history, key2]
+  };
+  const count = next3.board.filter((p) => p === turn + 1).length;
+  if (!next3.reserves[turn] && (count < 3 || !millMoves(next3).length))
+    next3.winner = s.turn;
+  else next3.draw = next3.history.filter((k) => k === key2).length >= 3;
+  return next3;
+}
+function playMills(s, type, to, from) {
+  if (!index(to, 24) || s.winner !== null || s.draw)
+    throw Error("Choose a legal point.");
+  const board = [...s.board], reserves = [...s.reserves];
+  if (type === "capture") {
+    if (!s.captures || !millCaptures(s).includes(to))
+      throw Error(
+        "Capture a piece outside a mill, unless all pieces are in mills."
+      );
+    board[to] = 0;
+    const next4 = { ...s, board, captures: s.captures - 1 };
+    return next4.captures && millCaptures(next4).length ? next4 : finishTurn(next4);
+  }
+  if (!["place", "move"].includes(type) || !millMoves(s).some(
+    (m) => m.to === to && m.from === (type === "place" ? null : from)
+  ))
+    throw Error(
+      "Place from your reserve or move to a connected point. With three pieces you may fly."
+    );
+  if (type === "place") reserves[s.turn]--;
+  else board[from] = 0;
+  board[to] = s.turn + 1;
+  const captures = Math.min(
+    linesAt(board, to).length,
+    board.filter((p) => p === 2 - s.turn).length
   );
+  const next3 = { ...s, board, reserves, captures };
+  return captures ? next3 : finishTurn(next3);
+}
+function millLastTurn(s) {
+  const boards = s.history.slice(-2).map((key2) => key2.split(":")[0].split(",").map(Number));
+  const after = boards.at(-1), before = boards.length === 2 ? boards[0] : Array(24).fill(0);
+  if (!after) return null;
+  const seat = Number(s.history.at(-1).split(":")[1]) === 0 ? 1 : 0;
+  const to = after.findIndex((p, i) => p === seat + 1 && before[i] !== seat + 1);
+  if (to < 0) return null;
+  const from = before.findIndex((p, i) => p === seat + 1 && after[i] !== seat + 1);
+  const captured = before.flatMap((p, i) => p === 2 - seat && after[i] !== p ? [i] : []);
+  return { seat, from: from < 0 ? null : from, to, captured };
 }
 
-// lib/multiplayer/catalog.ts
-var multiplayerGames = [
-  { "id": "amazons", "name": "Amazons", "symbol": "\u265B", "players": "2 players", "description": "Claim territory with queens and arrows. Every move reshapes the board.", "rules": "Four queens per player on a 10 by 10 board. Player 1 starts at A4,D1,G1,J4; Player 2 at A7,D10,G10,J7. Move a queen any unobstructed distance horizontally, vertically or diagonally, then shoot an arrow from its destination along another unobstructed queen line. The arrow permanently blocks its square; it can land on the square just vacated. Complete both steps as one turn. A player with no queen move loses. JSON move uses numeric zero-based row-major from/to and amount for the arrow, 0\u201399. Exact legal wire actions are supplied to the active player." },
-  { "id": "lines-of-action", "name": "Lines of Action", "symbol": "\u25CF", "players": "2 players", "description": "Bring your scattered stones together in a tactical race for connection.", "rules": "Claude Soucie\u2019s 8 by 8 connection game. Player 1 has six stones on each horizontal edge, Player 2 six on each vertical edge, with corners empty. Move any stone in one straight line exactly as many squares as there are stones of either color on that entire line. Jump over friendly stones but never enemies. Capture an enemy at the destination; never land on a friendly stone. Connect all your remaining stones into one group using orthogonal or diagonal adjacency to win; a single stone is connected. This edition awards simultaneous connection to the mover. An immobile player passes automatically; both immobile or three repetitions with the same player to move draw. This bounded-table edition also draws after 512 moves without connection. JSON move uses numeric row-major from/to, 0\u201363. Exact legal actions are listed." },
-  { "id": "last-greenhouse", "name": "The Last Greenhouse", "symbol": "\u2667", "players": "2 players \xB7 cooperative", "description": "Two private journals. Five locked rooms. Save the last seed bank together.", "rules": "An original cooperative escape-room story for two keepers. Read your private journal and compare it with your partner\u2019s observation to solve each room. Share publishes your current observation to both players; Pass hands the controls to your partner; Choose selects setting at 0\u20133 from the visible room options. Every action hands over the controls. Wrong answers are safe to retry and are included in the legal-action list. Complete the atrium, prism gallery, seed archive, pump room and dawn canopy together. Only your own private journal and shared notes are projected; spectators see no private journal. Local handoff conceals journals between turns. No competitive rating or Quick Play." },
-  { id: "euchre", name: "Euchre", symbol: "J", players: "4 players \xB7 2 teams", description: "Call trump, trust your partner, or take all five tricks alone.", rules: "Four players in opposite-seat partnerships. A 24-card deck uses 9 through ace. Each player receives five cards and one card is turned up. Starting left of dealer, order the turned suit or pass. If ordered, the dealer picks up the upcard and discards one card face down. After four passes, call any other suit; four more passes produce a fresh deal with the next dealer. A caller may go alone: their partner sits out. Left of dealer leads, skipping a sitting partner. Follow suit when possible. The trump jack is highest, followed by the other jack of the same color (the left bower, which belongs to trump), then A,K,Q,10,9 of trump. Other suits rank A,K,Q,J,10,9. Trick winner leads. Makers score 1 for three or four tricks, 2 for all five together, or 4 for all five alone. Defenders score 2 if makers take fewer than three. First team to 10 wins. No stick-the-dealer, joker or defensive lone hands. Hands and kitty remain private. Legal actions are enumerated for the active seat." },
-  { id: "cribbage", name: "Cribbage", symbol: "121", players: "2 players", description: "Choose your crib. Peg the count. Race to 121.", rules: "Two-player six-card cribbage with a standard deck. Aces are low. Each player discards two cards face down to the dealer's crib; the starter is revealed after both discard. A starter jack gives the dealer two points. Non-dealer leads pegging: play one card without exceeding 31, or say Go only when no card fits. Fifteen and thirty-one score two; consecutive pairs, triples and quads score two, six and twelve; the longest trailing run scores its length. The last card before a reset scores one except at 31. After a Go/reset the opponent of the last player leads if holding cards. Count non-dealer's hand, dealer's hand, then crib: fifteens, pairs, longest runs with multiplicities, four/five-card hand flushes, five-card-only crib flush, and one for a jack matching the starter's suit. Counting is automatic; no muggins. Dealer alternates. First to reach 121 at any scoring event wins immediately. Hidden cards and crib stay private until counting; spectators see only public cards. Exact legal JSON actions are supplied in visible_state.legalActions for the active player." },
-  { id: "fanorona", name: "Fanorona", symbol: "\u2194", players: "2 players", description: "Approach or withdraw. One move can capture a whole line.", rules: "Two players on the traditional 9 by 5 connected-point board, twenty-two stones each. Player 1 starts. Move one stone along a drawn line to an adjacent empty point. Captures are compulsory when available: approach captures the consecutive enemy line beyond the destination; withdrawal captures the consecutive enemy line behind the starting point. Choose one when both apply. After a capture you may continue with the same stone or Stop. A capture sequence cannot revisit a point or repeat the immediately preceding direction. A non-capturing move is allowed only when no capture exists. Capture every opposing stone or leave the opponent without a move to win. This implementation draws at three repetitions of the same position with the same player to move, or eighty completed turns without a capture. Intersections are zero-based row-major: top-left 0, bottom-right 44. JSON move uses from/to plus amount 0 for approach or a quiet move, 1 for withdrawal; stop ends an optional continuation. Exact legal actions are supplied in visible_state.legalActions." },
-  { "id": "categories", "name": "Categories", "symbol": "A\u2013Z", "players": "2\u20138 players", "description": "One letter. Six categories. Race your friends to a unique answer.", "rules": "Five English-language rounds with Country, City, Animal, Food, Occupation and Object. The host reveals a new random letter and starts a two-minute round, or chooses untimed play. Submit one locked answer sheet; blank answers are allowed. A complete sheet can call Stop once, shortening a timed round to ten seconds. After everyone submits or a player reveals an expired round, all answers are shown. Unsubmitted answers are blank. Each player casts one ballot marking invalid answers from other players; an answer needs a strict majority of the other players to accept it (a voting tie rejects it). Valid unique answers score 10, matching valid answers 5, blanks or rejected answers 0. Highest total after five rounds wins; equal totals draw. Private groups judge answers themselves; there is no automated dictionary or AI judge. Local play uses untimed private handoffs." },
-  { "id": "cheat", "name": "Cheat", "symbol": "?!", "players": "3\u20136 players", "description": "Play face down. Tell a convincing story. Call the bluff.", "rules": "Deal all 52 cards clockwise. Player 1 claims aces, then claims cycle through 2 to king and back to ace. On your turn place one to four cards face down, claiming the required rank; bluffing is allowed. Before the next play, any other player may challenge, or the next player may accept. A challenge reveals only the latest cards: if any is the wrong rank the claimant takes the whole pile; otherwise the challenger takes it. Accepted cards stay hidden. The next clockwise player then takes their turn with the next required rank. An empty hand wins only after its final claim is accepted or survives a challenge. This table uses an explicit challenge window without a reaction timer." },
-  { "id": "president", "name": "President", "symbol": "3\u21922", "players": "3\u20136 players", "description": "Beat the group. Pass at the right moment. Finish first.", "rules": "A single deal with a standard 52-card deck, all cards dealt clockwise. Ranks rise from 3 through ace, with 2 highest. The holder of 3 of clubs opens with a group containing it. Lead one to four equal-rank cards; following plays must contain the same number of cards at a strictly higher rank. You may pass, but cannot re-enter until that pile clears. When all other active players pass, the last player to play leads again; if they have finished, the next active player leads. Finishers leave play and receive places in order. Play continues until one player remains; the first finisher is President. No jokers, suit tie-breaks, special twos, revolution or between-deal tribute." },
-  { "id": "rummy", "name": "Classic Rummy", "symbol": "777", "players": "2\u20134 players", "description": "Draw a card. Build sets and runs. Empty your hand.", "rules": "One deal, no jokers. Two players receive ten cards each; three or four receive seven. Aces are low only. Draw one card from the stock or take the top discard. Then optionally meld sets of three or four equal ranks, or runs of three or more consecutive cards of one suit. You may add held cards to either end of any public run or complete a public set. Keep at least one card and end your turn by discarding; a taken upcard cannot be discarded immediately. First to discard their last card wins and scores the total value of cards held by opponents: ace 1, faces 10, other cards face value. Recycle discards beneath the top card when stock runs out. If stock and recyclable discards are both empty and the next player chooses stock, the deal ends; lowest remaining card value wins, with ties drawn. No initial meld threshold, knock or Rummy 500 scoring." },
-  { id: "tic-tac-toe", name: "Tic-tac-toe", symbol: "XO", players: "2 players", description: "Nine squares. Three in a row. Your next quick match.", rules: "X starts on a 3 by 3 board. Take turns placing your mark on an empty square. Three marks in a horizontal, vertical or diagonal line wins. A full board without a winner draws." },
-  { id: "international-draughts", name: "International Draughts", symbol: "\u265B", players: "2 players", description: "Twenty pieces. Flying kings. Capture the longest chain.", rules: "White starts on a 10\xD710 board with twenty pieces per side. Men move one diagonal square forward and capture in either direction. Kings slide diagonally and land on any empty square beyond a captured piece. Captures are compulsory: choose a sequence taking the greatest number of pieces. Captured pieces remain as blockers until the entire sequence ends. A man becomes a king only if its final square is on the promotion row. No pieces or no legal move loses. Threefold repetition, twenty-five successive king moves per player without captures or man moves, and the official sixteen/five-move king endgame limits draw automatically." },
-  { id: "atomic-chess", name: "Atomic Chess", symbol: "\u265C", players: "2 players", description: "Every capture explodes. Protect your king from the blast.", rules: "Standard chess setup and moves, with explosive captures: the capturing piece, captured piece and adjacent non-pawns disappear. Adjacent pawns survive. En passant explodes at the capturing pawn\u2019s destination. A move that explodes your own king is illegal. Kings cannot capture, but may stand next to one another. Explode the opposing king or deliver checkmate to win. Stalemate, insufficient material, threefold repetition or fifty moves without a pawn move or capture draws. Castling and all four promotions are supported." },
-  { id: "three-check", name: "Three-check", symbol: "\u2654", players: "2 players", description: "Give three checks to win. Every threat counts.", rules: "Standard chess rules, plus a second way to win: give your opponent check three times. A double check counts as one checking move. Checkmate also wins. Each player\u2019s checks are shown beside the board. Standard castling, en passant and all four promotions apply. Stalemate, insufficient material, threefold repetition or fifty moves without a pawn move or capture draws." },
-  { id: "connect-four", name: "Connect Four", symbol: "\u25CF", players: "2 players", description: "Drop a piece. Connect four. Watch the next column.", rules: "Two players alternate dropping pieces into one of seven columns on a six-row board. Each piece falls to the lowest empty space. Four or more pieces of your color in a horizontal, vertical or diagonal line wins. A full board without a winner draws." },
-  { id: "dots-boxes", name: "Dots & Boxes", symbol: "\u25A6", players: "2 players", description: "Complete a square. Claim another turn.", rules: "Players alternate drawing one unused edge on a 3 \xD7 3 box board. Completing the fourth side of a box claims it and gives another turn. An edge can complete two boxes. When all nine boxes are owned, most boxes wins. All information is public." },
-  { id: "battleships", name: "Battleships", symbol: "\u2693", players: "2 players", description: "Hide your fleet. Read the hits. Find the last ship.", rules: "Each player secretly places five straight ships of lengths 5, 4, 3, 3 and 2 on a 10\xD710 grid. Ships may touch but cannot overlap or leave the grid. Tap a starting square to place the next ship; switch horizontal/vertical or arrange automatically, then lock the fleet. Player 1 sets up first, then Player 2. Player 1 fires first. Take exactly one shot per turn, including after a hit. The target grid marks hits and misses, and reveals a ship when every square is hit. Sink all five enemy ships to win. On one device, hide your fleet before passing it. Online, only your own ships and already-known shot results are sent to your browser." },
-  {
-    id: "thousand",
-    name: "Thousand",
-    symbol: "1000",
-    players: "2\u20134 players",
-    description: "Bid your hand. Marry a new trump.",
-    rules: "A 24-card deck, nine through ace; strength is nine, jack, queen, king, ten, ace. Three active players receive seven cards and a three-card kitty. With four seats the dealer sits out and scores revealed kitty aces (50 each) and marriages. Two players receive ten cards each and choose one of two two-card kitties. The first active player opens at 100; bid in tens, no higher than 120 plus held marriages. Winner takes a kitty, gives each other active player a card (or discards two with two seats), then declares at least the auction bid. Follow suit and beat the winner when possible; if void, trump when held. Leading a held queen-king pair with the marriage declaration earns clubs 60, diamonds 80, hearts 100 or spades 40 and changes trump. Card points: ace 11, ten 10, king 4, queen 3, jack 2. Remaining kitty cards score for the last trick winner. Declarer makes or loses their contract; others round their points to tens. At 800, only declarer earns further points. First to 1000 wins, with declarer winning a simultaneous finish. The first bomb cancels freely; subsequent bombs award opponents 60 (40 with four seats). Four nines can request a redeal."
-  },
-  {
-    id: "binokel",
-    name: "Binokel",
-    symbol: "AA",
-    players: "4 players",
-    description: "Four copies. Two partners. One contract.",
-    rules: "Partners sit opposite. Four copies of jack, queen, king, ten and ace in every suit form an 80-card deck; twenty cards each. Auction starts at 50, rises by one below 60 and by five thereafter. Passed players leave the auction. If the first three pass, dealer plays 50. Declarer chooses trump only from a held queen-king pair; no pair loses the contract. The declaring partnership needs at least 20 meld points. Melds score automatically and their cards are revealed: aces/kings/queens/jacks around; ordinary and royal marriages; spade queen with diamond jack; and a trump A-10-K-Q-J run. Duplicate melds use the full single/double/triple/quadruple table. A royal marriage already in a run is not counted twice. Follow suit and beat the current winner when possible; when void, trump and overtrump when possible. Equal copies favor the first played. Each ace, ten or king taken earns one; last trick earns two. At least 20 trick points are required to score a hand, and at least 20 meld points to add melds. Declarers reaching their bid score their total, otherwise lose the bid. Opponents score qualifying totals. First team to 500 wins; if both reach 500, the declaring team wins."
-  },
-  {
-    id: "skat",
-    name: "Skat",
-    symbol: "J",
-    players: "3 players",
-    description: "Win the bidding duel. Play alone against two.",
-    rules: "Thirty-two cards, seven through ace. Middlehand speaks values to forehand, who holds or passes; rearhand then speaks to the survivor. If both speakers pass without a bid, forehand plays 18 or passes out. Declarer picks up the two-card skat and discards two, or plays from hand. Choose a suit, Grand (only jacks trump) or Null (lose every trick). Jacks rank clubs, spades, hearts, diamonds above suit trumps. Other suit/Grand cards rank A-10-K-Q-9-8-7; Null ranks A-K-Q-J-10-9-8-7. Follow the effective suit; jacks belong to trump in suit/Grand games. Forehand always leads. Suit/Grand need 61 card points, including skat; Null ends in loss on declarer\u2019s first trick. Value multiplies suit base (diamonds 9, hearts 10, spades 11, clubs 12, Grand 24) by matadors, game, hand and Schneider/Schwarz/open levels. Hand games can announce 90 points or all tricks. Null values are 23, hand 35, open 46, open hand 59. Lost or overbid games subtract twice their value, rounding overbids up to a sufficient base multiple. Highest score after eighteen hands wins. No Ramsch, Kontra or tournament bonus variant."
-  },
-  {
-    id: "baska",
-    name: "Baska",
-    symbol: "DQ",
-    players: "4 players",
-    description: "Find your hidden partner in sixteen cards.",
-    rules: "The red (heart-ace) variant, sixteen cards: ace, ten, queen and jack in each suit. Trump strength: heart ace, heart ten, queens clubs-spades-hearts-diamonds, jacks in that order, diamond ace, diamond ten. Other cards keep their printed suits. Old partners hold club and spade queens; holding both creates a silent solo. Wedding pairs that holder with the first available club, spade or heart jack holder. Auction offers Grand, Zolo and their all-trick Du contracts, with alternating counters up to redouble. Grand has only jack trumps. Four tens, aces or queens automatically claim Zolo Bieda, Master or Baska. Follow suit and beat the winner when possible. Card points are A11, 10=10, Q3, J2. Old side needs 53; with 52\u201352, the side that last countered loses. Ordinary/wedding stakes rise for failure to reach 26 (young) or 27 (old), or failure to take a trick; old losses cost twice. Silent solo stakes four, Grand/Zolo five, Du/honor ten, all doubled by counters. Paired winners gain the stake each; a solo winner gains it from each opponent; highest total after sixteen hands wins. Black and three-tens variants are outside this table."
-  },
-  {
-    id: "canasta",
-    name: "Canasta",
-    symbol: "77",
-    players: "2 or 4 players",
-    description: "Build seven-card melds. Break a frozen pile.",
-    rules: "Two 54-card decks, including four jokers. Two players get fifteen cards and draw two; four players get eleven and draw one, sharing melds with the opposite partner. Meld matching natural ranks with at least two natural cards and at least three total; at most three wild twos/jokers, with no more wild than natural. Seven or more cards form a canasta. Opening melds total 15 below zero score, 50 below 1500, 90 below 3000, then 120. Take the entire discard pile only by immediately melding its top; a frozen pile requires two matching natural cards held. Wild cards block pickup and freeze the pile; black threes block pickup except a final meld. Red threes are set aside and replaced when drawn from stock. Black threes meld only when going out. End a turn by discarding one. Going out requires two canastas with two players, one with partners; premature going out loses the match. Natural canastas earn 500, mixed 300; going out 100, concealed opening 200. Red threes earn 100 each plus 400 for all four, negative without a meld. Melded cards score positive, held cards negative. Card values: joker50, A/2=20, 8\u2013K=10, others5. Highest score reaching 5000 wins. Optional partner permission is not required."
-  },
-  {
-    id: "bridge",
-    name: "Bridge",
-    symbol: "NT",
-    players: "4 players",
-    description: "Bid a contract. Plan two hands together.",
-    rules: "Partners sit opposite. A sixteen-board match uses standard duplicate contract scores and the rotating vulnerability cycle. Each player has thirteen cards. Bids increase by level and strain: clubs, diamonds, hearts, spades, no trump. Three passes after a bid end the auction; four opening passes pass out the board. Opponents may double; the declaring side may redouble. Declarer is the first player in the winning partnership to bid the final strain. The player to declarer\u2019s left leads. Dummy is exposed after that lead and declarer controls its plays. Follow suit when possible; highest trump or lead-suit card wins. Contract, game, slam, overtrick and undertrick scores account for doubling and vulnerability. Highest net team score after sixteen boards wins. This table uses raw duplicate scores; Kurnik\u2019s HCP-adjusted IMP table, conventions, claims and tournament director rulings are outside this variant."
-  },
-  {
-    id: "polish-hearts",
-    name: "Polish Hearts",
-    symbol: "\u2665",
-    players: "3\u20134 players",
-    description: "Avoid seven penalties, then win points back.",
-    rules: "Seven penalty hands: each trick costs 20; each heart 20; queen 60; king or jack 30; heart king 150; seventh and last tricks 75 each; the seventh hand combines all penalties. Follow suit, with no obligation to beat the current winner. Hearts cannot lead while another suit is held in the heart, heart-king and combined hands. Next, each player deals a trump hand and chooses trump from the first five cards, before the rest are dealt; each trick earns 25. Finally, build four suit columns around the dealer\u2019s opening rank; extend a column by one rank, or start another at that opening rank. Play whenever possible. First out earns 800, second 500. Three-player games omit the club two, use six cards for the trump choice, cost 15 per trick, 140 for the heart king and 70 per special trick, earn 20 per trump trick and award 790/485 for the final layout. Highest total wins."
-  },
-  {
-    id: "durak",
-    name: "Durak",
-    symbol: "\u2660",
-    players: "2\u20134 players",
-    description: "Beat the attack. Empty your hand.",
-    rules: "Individual throw-in Durak with 36 cards, six through ace. Deal six each; the bottom stock card shows trump and is drawn last. The lowest dealt trump holder opens. Attack with one card, then add ranks already on the table, including defended ranks. The defender beats a card with a higher card of the same suit or any trump over a nontrump. Attacks are capped at six cards or the defender\u2019s starting hand size. The main attacker has first priority; finishing offers other attackers a clockwise turn. Taking opens a final throw-in window, then the defender collects all table cards and skips their next attack. Successful defense discards the table and the defender attacks next. Refill the main attacker first, other players clockwise and defender last. Empty hands leave once the stock runs out. The last player holding cards loses; simultaneous empty hands draw. This table has no transfer attacks, teams or optional trump-six exchange."
-  },
-  {
-    id: "makao",
-    name: "Makao",
-    symbol: "Q",
-    players: "2\u20134 players",
-    description: "Match suits and ranks. Counter the demand.",
-    rules: "Five cards each from a 52-card deck. Match the pile\u2019s suit or rank, or play a queen on an ordinary card; any ordinary card fits a queen. Groups of the same rank can be played together, with the first card matching. Twos and threes add draw penalties; the heart king adds five to the next player, the spade king to the previous player. Penalties can be stacked with any fighting card. Fours add waiting turns, countered with fours. Jacks request an ordinary rank for one complete cycle, or cancel a request; aces request a suit for the next player. Queens do not override demands. A normal draw offers only that new card for immediate play. Say Makao with the checkbox when one card remains; the next player can catch a missed declaration for five cards. When both stock and reusable discards run out, every player returns a random half of their hand, rounded down. The first empty hand wins. No jokers or sequence-chain variant."
-  },
-  {
-    id: "three-five-eight",
-    name: "3-5-8",
-    symbol: "358",
-    players: "3 players",
-    description: "Meet your quota. Exchange for stronger cards.",
-    rules: "Eighteen hands with a 52-card deck. Sixteen cards each and a four-card kitty. Dealer targets eight tricks, the next player five, the third three. Each player chooses each of the six contracts once on their own deals: four trump suits, no trump and no tricks. Discard four before taking the kitty. Follow suit; if void, play trump when held. Highest trump or highest lead suit wins. Ordinary hands score tricks minus quota; no-tricks reverses that score. Before subsequent hands, players above their previous quota exchange one unwanted card per surplus trick with players below quota; the receiver automatically returns their highest card in its suit. Higher current quotas exchange first. Highest total after eighteen hands wins. This uses the eighteen-hand contract variant rather than the twelve-trick sudden-win variant."
-  },
-  {
-    id: "property-trading",
-    name: "Property Trading",
-    symbol: "\u2302",
-    players: "2\u20134 players",
-    description: "Build a garden estate. Bargain for a complete street.",
-    rules: "An original forty-space estate board with classic property trading rules. Each player starts with 1,500 points; passing Start earns 200. Roll two dice, buy unowned properties or auction them to all players. Doubles earn another roll; three consecutive doubles send you to jail. Collect rents, complete color groups and build evenly using the finite bank of 32 houses and 12 hotels. Mortgage unbuilt properties for half their price; redeem for 60%. Trade unbuilt properties and cash by an explicit offer and acceptance; receiving a mortgaged property costs 10% of its price. Jail ends with doubles, a release card or a payment of 50; the third failed roll forces payment. Income tax is 200 or 10% of estate value; luxury tax is 75. Free Park pays nothing. Resolve debts by selling buildings or mortgaging assets; bankruptcy transfers an estate to the creditor, or auctions it for bank debts. The last solvent player wins. Free points only."
-  },
-  {
-    id: "draw-guess",
-    name: "Draw & Guess",
-    symbol: "\u270E",
-    players: "2\u201320 players",
-    description: "A private word. A shared sketch.",
-    rules: "Take turns drawing one of three private English prompts. You have two minutes. Other players guess while the drawing updates. A correct guess earns 1\u201345 points based on remaining time, and the drawer earns up to five more, capped at 45, for that guess. Each player can score once per round. If everyone guesses, the round ends early. No correct guesses costs the drawer ten. First to 100 ends the match; highest score wins. Draw pictures rather than writing the word. Local play offers a player switch and hides the prompt from guessers."
-  },
-  {
-    id: "letter-tiles",
-    name: "Letter Tiles",
-    symbol: "A",
-    players: "2\u20134 players",
-    description: "Build a crossword. Make every letter count.",
-    rules: "American English Scrabble-style home scoring on the standard 15 \xD7 15 premium-square layout, with 100 tiles and seven per rack. First word: at least two letters covering the center double-word square. Place connected tiles in one row or column without gaps; every new or crossed word scores, including existing letters. English values: A E I L N O R S T U 1; D G 2; B C M P 3; F H V W Y 4; K 5; J X 8; Q Z 10. Blanks stay zero and keep their chosen letter. DL/TL multiply each newly placed letter; DW/TW multiply its whole word after letter bonuses. New premiums apply to every word using that tile, once on its placement turn; multiple word multipliers multiply together. Using seven new tiles adds 50 after all multipliers. Next player accepts or challenges against our ENABLE English word-game list with QI/ZA additions; accepted words differ from official NWL/Collins lists. Invalid words return the tiles and lose the proposer\u2019s turn; a failed challenge loses the challenger\u2019s next turn. Exchange any number of rack tiles as often as needed, using a turn, when at least seven remain in the bag. Everyone passing twice ends play, as does emptying a rack with an empty bag. Deduct unplayed tiles; the player going out also receives opponents\u2019 deductions. Highest final score wins; a final tie favors the higher pre-adjustment score. Earlier rounds retain their original rules until restarted."
-  },
-  {
-    id: "pan",
-    name: "Pan",
-    symbol: "\u2667",
-    players: "2\u20134 players",
-    description: "Shed your cards before the pile turns.",
-    rules: "A 24-card deck, nine through ace. The holder of the heart nine opens with that card or all four nines. Play one card or all four of a rank, no lower than the pile top. With only the heart nine on the pile, the other three nines can be played together. Instead of playing, take up to three top cards, leaving the heart nine. Empty hands leave the round. The last player receives a P, then A, then N; three letters loses the match. A last player who can immediately shed one or four aces draws the round. This table uses the ordinary clockwise variant."
-  },
-  {
-    id: "gin-rummy",
-    name: "Gin Rummy",
-    symbol: "\u2666",
-    players: "2 players",
-    description: "Build runs and sets. Know when to knock.",
-    rules: "Ten cards each. The dealer\u2019s opponent may take the opening upcard; if passed, the dealer may take it. If both pass, draw from stock. Draw one, then discard another; you cannot return the upcard just drawn. Meld sets of three/four equal ranks or same-suit runs of at least three, ace low. Knock when the remaining deadwood is at most ten: ace one, face cards ten. Melds and opponent layoffs are optimized automatically. Gin earns deadwood difference plus 25; an equal or lower opponent deadwood undercuts for 25 plus difference. At 100, the game ends with game and hand bonuses. Two cards left in stock cancels the round with the same dealer."
-  },
-  {
+// lib/multiplayer/cribbage.ts
+var cribbageLabel = (c) => ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"][c % 13] + ["\u2663", "\u2666", "\u2665", "\u2660"][Math.floor(c / 13)];
+
+// lib/multiplayer/dots-boxes.ts
+function boxEdges(size, box) {
+  const x = box % size, y = Math.floor(box / size), offset = size * (size + 1);
+  return [
+    y * size + x,
+    (y + 1) * size + x,
+    offset + y * (size + 1) + x,
+    offset + y * (size + 1) + x + 1
+  ];
+}
+
+// lib/multiplayer/trick-cards.ts
+var cardSuit = (card2) => Math.floor(card2 / 13);
+var cardRank = (card2) => card2 % 13 + 2;
+var cardLabel = (card2) => `${["", "", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"][cardRank(card2)]}${["\u2663", "\u2666", "\u2665", "\u2660"][cardSuit(card2)]}`;
+var penalty = (card2) => cardSuit(card2) === 2 ? 1 : card2 === 49 ? 13 : 0;
+function first(s) {
+  return s.variant === "spades" ? s.dealer : (s.dealer + 1) % s.hands.length;
+}
+function deal(s, entropy2) {
+  const count = s.hands.length, size = s.variant === "oh-hell" ? Math.max(1, (count === 4 ? 13 : 17) - s.round) : 13, deck = shuffled(
+    Array.from({ length: 52 }, (_, i) => i),
+    entropy2
+  );
+  const hands = Array.from(
+    { length: count },
+    (_, i) => deck.slice(i * size, (i + 1) * size).sort((a, b) => a - b)
+  );
+  const t = {
+    ...s,
+    size,
+    hands,
+    stock: deck.slice(count * size),
+    trick: [],
+    lastTrick: [],
+    tricks: Array(count).fill(0),
+    penalties: Array(count).fill(0),
+    bids: Array(count).fill(null),
+    blind: Array(count).fill(false),
+    blindAsked: Array(count).fill(false),
+    selected: Array.from({ length: count }, () => []),
+    passed: Array(count).fill(false),
+    broken: false,
+    winner: null,
+    result: ""
+  };
+  t.trump = s.variant === "spades" ? 3 : s.variant === "oh-hell" && s.round > 0 ? cardSuit(t.stock[0]) : null;
+  t.phase = s.variant === "hearts" ? s.round % 4 === 3 ? "play" : "pass" : s.variant === "spades" && Math.abs(s.scores[0] - s.scores[1]) >= 200 ? "blind" : "bid";
+  t.turn = s.variant === "hearts" ? t.phase === "play" ? hands.findIndex((h) => h.includes(0)) : 0 : first(t);
+  return t;
+}
+function createTrickCards(variant, count, entropy2) {
+  if (!index(count - 2, 3) || variant !== "oh-hell" && count !== 4)
+    throw Error("Choose the required player count.");
+  return deal(
+    {
+      variant,
+      turn: 0,
+      dealer: Math.floor(draws(entropy2, 1)[0] * count),
+      round: 0,
+      size: 13,
+      phase: "bid",
+      hands: Array.from({ length: count }, () => []),
+      stock: [],
+      trick: [],
+      lastTrick: [],
+      tricks: [],
+      penalties: [],
+      bids: [],
+      blind: [],
+      blindAsked: [],
+      selected: [],
+      passed: [],
+      scores: Array(variant === "spades" ? 2 : count).fill(0),
+      bags: [0, 0],
+      trump: null,
+      broken: false,
+      winner: null,
+      result: ""
+    },
+    entropy2
+  );
+}
+function trickLegalCards(s) {
+  if (s.phase !== "play") return [];
+  const hand2 = s.hands[s.turn].filter((c) => c !== null), lead = s.trick[0];
+  if (lead) {
+    const suited = hand2.filter((c) => cardSuit(c) === cardSuit(lead.card));
+    if (suited.length) return suited;
+    if (s.variant === "hearts" && s.tricks.every((n) => n === 0)) {
+      const clean = hand2.filter((c) => !penalty(c));
+      if (clean.length) return clean;
+    }
+    return hand2;
+  }
+  if (s.variant === "hearts") {
+    if (s.tricks.every((n) => n === 0)) return hand2.includes(0) ? [0] : [];
+    if (!s.broken) {
+      const clean = hand2.filter((c) => cardSuit(c) !== 2);
+      if (clean.length) return clean;
+    }
+  }
+  if (s.variant === "spades" && !s.broken) {
+    const clean = hand2.filter((c) => cardSuit(c) !== 3);
+    if (clean.length) return clean;
+  }
+  return hand2;
+}
+function finish(s) {
+  if (s.variant === "hearts") {
+    s.scores = s.scores.map((n, i) => n + s.penalties[i]);
+    s.result = `Round penalties: ${s.penalties.join(" \xB7 ")}`;
+    if (s.scores.some((n) => n >= 100)) {
+      s.phase = "finished";
+      s.winner = best(s.scores.map((n) => -n));
+    } else s.phase = "round";
+  } else if (s.variant === "spades") {
+    const gains = [0, 0];
+    for (const team2 of [0, 1]) {
+      const seats2 = [team2, team2 + 2], bid = seats2.reduce((n, i) => n + s.bids[i], 0), taken = seats2.filter((i) => s.bids[i] !== 0).reduce((n, i) => n + s.tricks[i], 0);
+      gains[team2] = taken >= bid ? bid * 10 + Math.max(0, taken - bid) : -bid * 10;
+      const bags = Math.max(0, taken - bid) + seats2.filter((i) => s.bids[i] === 0).reduce((n, i) => n + s.tricks[i], 0);
+      s.bags[team2] += bags;
+      gains[team2] -= 100 * Math.floor(s.bags[team2] / 10);
+      s.bags[team2] %= 10;
+      for (const i of seats2)
+        if (s.bids[i] === 0)
+          gains[team2] += (s.tricks[i] === 0 ? 1 : -1) * (s.blind[i] ? 200 : 100);
+    }
+    s.scores = s.scores.map((n, i) => n + gains[i]);
+    s.result = `Team 1 & 3: ${gains[0]} \xB7 Team 2 & 4: ${gains[1]}`;
+    if (s.scores.some((n) => n >= 500 || n <= -200)) {
+      s.phase = "finished";
+      s.winner = best(s.scores);
+    } else s.phase = "round";
+  } else {
+    s.scores = s.scores.map(
+      (n, i) => n + (s.bids[i] === s.tricks[i] ? 10 + s.tricks[i] : 0)
+    );
+    s.result = `Tricks taken: ${s.tricks.join(" \xB7 ")}`;
+    const rounds = (s.hands.length === 4 ? 13 : 17) + s.hands.length - 1;
+    if (s.round + 1 >= rounds) {
+      s.phase = "finished";
+      s.winner = best(s.scores);
+    } else s.phase = "round";
+  }
+  s.turn = first(s);
+}
+function playTrickCards(s, type, at, amount, entropy2) {
+  if (s.phase === "finished") throw Error("This match is finished.");
+  if (type === "next" && s.phase === "round")
+    return deal(
+      { ...s, round: s.round + 1, dealer: (s.dealer + 1) % s.hands.length },
+      entropy2
+    );
+  const t = structuredClone(s), seat = s.turn, count = s.hands.length;
+  if (s.phase === "pass") {
+    if (type === "select" && at !== void 0 && s.hands[seat].includes(at)) {
+      const selected = t.selected[seat];
+      if (selected.includes(at))
+        t.selected[seat] = selected.filter((c) => c !== at);
+      else if (selected.length < 3) selected.push(at);
+      else throw Error("Select three cards.");
+      return t;
+    }
+    if (type !== "pass" || t.selected[seat].length !== 3)
+      throw Error("Choose three cards to pass.");
+    t.passed[seat] = true;
+    if (t.passed.every(Boolean)) {
+      const offset = [1, 3, 2][s.round % 4];
+      t.hands = t.hands.map(
+        (h, i) => h.filter((c) => !t.selected[i].includes(c))
+      );
+      t.selected.forEach(
+        (cards, i) => t.hands[(i + offset) % 4].push(...cards)
+      );
+      t.hands.forEach((h) => h.sort((a, b) => a - b));
+      t.selected = t.selected.map(() => []);
+      t.phase = "play";
+      t.turn = t.hands.findIndex((h) => h.includes(0));
+    } else t.turn = t.passed.findIndex((n) => !n);
+    return t;
+  }
+  if (s.phase === "blind") {
+    const eligible = s.scores[1 - seat % 2] - s.scores[seat % 2] >= 200;
+    if (type === "blind" && eligible) {
+      t.bids[seat] = 0;
+      t.blind[seat] = true;
+    } else if (type !== "look")
+      throw Error("Choose blind nil or look at your cards.");
+    t.blindAsked[seat] = true;
+    if (t.blindAsked.every(Boolean)) {
+      t.phase = "bid";
+      t.turn = first(t);
+      while (t.bids[t.turn] !== null) t.turn = (t.turn + 1) % count;
+    } else t.turn = (seat + 1) % count;
+    return t;
+  }
+  if (s.phase === "bid") {
+    if (type !== "bid" || amount === void 0 || !index(amount, s.size + 1))
+      throw Error("Choose a legal bid.");
+    if (s.variant === "oh-hell" && s.bids.filter((b) => b !== null).length === count - 1 && s.bids.reduce((n, b) => n + (b ?? 0), 0) + amount === s.size)
+      throw Error("The last bid cannot make the total equal the hand size.");
+    t.bids[seat] = amount;
+    if (t.bids.every((b) => b !== null)) {
+      t.phase = "play";
+      t.turn = first(t);
+    } else {
+      t.turn = (seat + 1) % count;
+      while (t.bids[t.turn] !== null) t.turn = (t.turn + 1) % count;
+    }
+    return t;
+  }
+  if (s.phase === "moon") {
+    if (type !== "moon" || ![0, 1].includes(amount ?? -1))
+      throw Error("Choose how to score the moon.");
+    t.penalties = t.penalties.map(
+      (_, i) => amount === 0 ? i === seat ? -26 : 0 : i === seat ? 0 : 26
+    );
+    finish(t);
+    return t;
+  }
+  if (type !== "play" || at === void 0 || !trickLegalCards(s).includes(at))
+    throw Error("Choose a legal card.");
+  t.hands[seat] = t.hands[seat].filter((c) => c !== at);
+  t.trick.push({ seat, card: at });
+  if (s.variant === "spades" && cardSuit(at) === 3 && s.trick.length > 0 && cardSuit(s.trick[0].card) !== 3 || s.variant === "hearts" && (cardSuit(at) === 2 || at === 49))
+    t.broken = true;
+  t.turn = (seat + 1) % count;
+  if (t.trick.length === count) {
+    const lead = cardSuit(t.trick[0].card), strength = (c) => (cardSuit(c) === s.trump ? 100 : cardSuit(c) === lead ? 50 : 0) + cardRank(c);
+    const winner2 = t.trick.reduce(
+      (a, b) => strength(b.card) > strength(a.card) ? b : a
+    ).seat;
+    t.tricks[winner2]++;
+    t.penalties[winner2] += t.trick.reduce((n, c) => n + penalty(c.card), 0);
+    t.lastTrick = t.trick;
+    t.trick = [];
+    t.turn = winner2;
+    if (t.hands.every((h) => !h.length)) {
+      const moon = s.variant === "hearts" ? t.penalties.findIndex((n) => n === 26) : -1;
+      if (moon >= 0) {
+        t.phase = "moon";
+        t.turn = moon;
+      } else finish(t);
+    }
+  }
+  return t;
+}
+function trickView(s, seat) {
+  const { stock, selected, ...publicState } = s;
+  return {
+    ...publicState,
+    stockCount: stock.length,
+    selected: selected.map((cards, i) => i === seat ? cards : []),
+    hands: s.hands.map(
+      (h, i) => i === seat && !(s.phase === "blind" && !s.blindAsked[i]) ? h : h.map(() => null)
+    )
+  };
+}
+
+// lib/multiplayer/gin-rummy.ts
+var ginRank = (c) => cardRank(c) === 14 ? 1 : cardRank(c);
+var ginValue = (c) => Math.min(10, ginRank(c));
+function ginMelds(hand2) {
+  const melds = [];
+  for (let rank2 = 1; rank2 <= 13; rank2++) {
+    const cards = hand2.filter((c) => ginRank(c) === rank2);
+    if (cards.length >= 3) {
+      if (cards.length === 4) {
+        melds.push(cards);
+        for (let i = 0; i < 4; i++) melds.push(cards.filter((_, j) => j !== i));
+      } else melds.push(cards);
+    }
+  }
+  for (let suit = 0; suit < 4; suit++) {
+    const cards = hand2.filter((c) => cardSuit(c) === suit).sort((a, b) => ginRank(a) - ginRank(b));
+    for (let start = 0; start < cards.length; start++)
+      for (let end = start + 2; end < cards.length; end++) {
+        const slice = cards.slice(start, end + 1);
+        if (slice.every(
+          (c, i) => i === 0 || ginRank(c) === ginRank(slice[i - 1]) + 1
+        ))
+          melds.push(slice);
+        else break;
+      }
+  }
+  return melds;
+}
+function partitions(hand2) {
+  const melds = ginMelds(hand2), out2 = [];
+  function visit(start, used, chosen) {
+    const deadwood2 = hand2.filter((c) => !used.has(c));
+    out2.push({
+      melds: chosen,
+      deadwood: deadwood2,
+      value: deadwood2.reduce((n, c) => n + ginValue(c), 0)
+    });
+    for (let i = start; i < melds.length; i++)
+      if (melds[i].every((c) => !used.has(c)))
+        visit(i + 1, /* @__PURE__ */ new Set([...used, ...melds[i]]), [...chosen, melds[i]]);
+  }
+  visit(0, /* @__PURE__ */ new Set(), []);
+  return out2;
+}
+function ginLayout(hand2) {
+  return partitions(hand2).reduce((a, b) => b.value < a.value ? b : a);
+}
+function ginLayoffValue(hand2, onto) {
+  const cache = /* @__PURE__ */ new Map();
+  function attach(cards, melds) {
+    const key2 = cards.join(",") + "|" + melds.map((m) => m.join(",")).join(";"), cached = cache.get(key2);
+    if (cached !== void 0) return cached;
+    let best2 = cards.reduce((n, c) => n + ginValue(c), 0);
+    cards.forEach(
+      (c, i) => melds.forEach((m, j) => {
+        const set = m.every((x) => ginRank(x) === ginRank(m[0])), ranks = m.map(ginRank), fits = set ? m.length === 3 && ginRank(c) === ranks[0] : cardSuit(c) === cardSuit(m[0]) && (ginRank(c) === Math.min(...ranks) - 1 || ginRank(c) === Math.max(...ranks) + 1);
+        if (fits) {
+          const next3 = melds.map(
+            (m2, k) => k === j ? [...m2, c].sort((a, b) => ginRank(a) - ginRank(b)) : m2
+          );
+          best2 = Math.min(
+            best2,
+            attach(
+              cards.filter((_, k) => k !== i),
+              next3
+            )
+          );
+        }
+      })
+    );
+    cache.set(key2, best2);
+    return best2;
+  }
+  return Math.min(...partitions(hand2).map((p) => attach(p.deadwood, onto)));
+}
+function deal2(dealer, scores2, wins, round, entropy2) {
+  const deck = shuffled(
+    Array.from({ length: 52 }, (_, i) => i),
+    entropy2
+  );
+  return {
+    hands: [
+      deck.slice(0, 10).sort((a, b) => a - b),
+      deck.slice(10, 20).sort((a, b) => a - b)
+    ],
+    stock: deck.slice(21),
+    discard: [deck[20]],
+    turn: 1 - dealer,
+    dealer,
+    phase: "offer",
+    offers: 0,
+    drawnDiscard: null,
+    scores: scores2,
+    wins,
+    winner: null,
+    round,
+    result: "",
+    revealed: [],
+    margin: null
+  };
+}
+function createGin(entropy2) {
+  return deal2(Math.floor(draws(entropy2, 1)[0] * 2), [0, 0], [0, 0], 0, entropy2);
+}
+function playGin(s, type, at, entropy2) {
+  if (type === "next" && s.phase === "round")
+    return deal2(
+      s.result.startsWith("Stock") ? s.dealer : 1 - s.dealer,
+      s.scores,
+      s.wins,
+      s.round + 1,
+      entropy2
+    );
+  if (["finished", "round"].includes(s.phase))
+    throw Error("This round is finished.");
+  const t = structuredClone(s), seat = s.turn;
+  if (type === "pass" && s.phase === "offer") {
+    t.offers++;
+    if (t.offers === 2) {
+      t.phase = "draw";
+      t.turn = 1 - s.dealer;
+    } else t.turn = 1 - seat;
+    return t;
+  }
+  if (["draw", "offer"].includes(s.phase) && ["stock", "upcard"].includes(type)) {
+    if (s.phase === "offer" && type === "stock")
+      throw Error("Take the upcard or pass the opening offer.");
+    if (s.phase === "draw" && s.offers === 2 && s.round === t.round && type === "upcard")
+      throw Error("Both players passed: draw from the stock.");
+    if (s.stock.length <= 2) {
+      t.phase = "round";
+      t.result = "Stock exhausted: round cancelled, same dealer.";
+      t.turn = s.dealer;
+      return t;
+    }
+    const card2 = type === "upcard" ? t.discard.pop() : t.stock.shift();
+    t.drawnDiscard = type === "upcard" ? card2 : null;
+    t.hands[seat].push(card2);
+    t.hands[seat].sort((a, b) => a - b);
+    t.phase = "discard";
+    t.offers = 0;
+    return t;
+  }
+  if (s.phase === "discard" && ["discard", "knock"].includes(type) && at !== void 0 && s.hands[seat].includes(at) && at !== s.drawnDiscard) {
+    t.hands[seat] = t.hands[seat].filter((c) => c !== at);
+    t.discard.push(at);
+    t.drawnDiscard = null;
+    if (type === "knock") {
+      const layout = ginLayout(t.hands[seat]);
+      if (layout.value > 10)
+        throw Error("Knock only with ten or fewer deadwood points.");
+      const other = 1 - seat, opp = layout.value === 0 ? ginLayout(t.hands[other]).value : ginLayoffValue(t.hands[other], layout.melds), winner2 = layout.value === 0 || layout.value < opp ? seat : other;
+      const points = layout.value === 0 ? opp + 25 : winner2 === seat ? opp - layout.value : layout.value - opp + 25;
+      t.scores[winner2] += points;
+      t.wins[winner2]++;
+      t.result = `${layout.value === 0 ? "Gin" : winner2 === seat ? "Knock" : "Undercut"}: Player ${winner2 + 1} scores ${points}. Deadwood ${layout.value} vs ${opp}.`;
+      t.revealed = t.hands.map((h) => ginLayout(h).melds);
+      t.phase = t.scores[winner2] >= 100 ? "finished" : "round";
+      t.turn = winner2;
+      if (t.phase === "finished") {
+        t.winner = winner2;
+        t.margin = t.scores[winner2] + 100 + (t.scores[other] === 0 ? 100 : 0) + 25 * t.wins[winner2] - t.scores[other] - 25 * t.wins[other];
+        t.result += ` Final margin including game and hand bonuses: ${t.margin}.`;
+      }
+    } else {
+      t.phase = "draw";
+      t.turn = 1 - seat;
+    }
+    return t;
+  }
+  throw Error("Choose a legal draw, discard or knock.");
+}
+function ginView(s, seat) {
+  const { stock, ...rest } = s;
+  return {
+    ...rest,
+    stockCount: stock.length,
+    hands: s.hands.map(
+      (h, i) => i === seat || ["round", "finished"].includes(s.phase) ? h : h.map(() => null)
+    )
+  };
+}
+
+// lib/multiplayer/oware.ts
+var side = (at) => at < 6 ? 0 : 1;
+function sow(pits, at) {
+  const board = [...pits];
+  let seeds = board[at], last = at;
+  board[at] = 0;
+  while (seeds > 0) {
+    last = (last + 1) % 12;
+    if (last !== at) {
+      board[last]++;
+      seeds--;
+    }
+  }
+  return { board, last };
+}
+function owareMoves(s) {
+  if (s.finished) return [];
+  const opponentEmpty = s.pits.every((n, i) => side(i) === s.turn || n === 0);
+  return s.pits.flatMap(
+    (n, at) => n > 0 && side(at) === s.turn && (!opponentEmpty || sow(s.pits, at).board.some((n2, i) => side(i) !== s.turn && n2 > 0)) ? [at] : []
+  );
+}
+
+// lib/multiplayer/catalog.ts
+var multiplayerGames = [
+  { "id": "amazons", "name": "Amazons", "symbol": "\u265B", "players": "2 players", "description": "Claim territory with queens and arrows. Every move reshapes the board.", "rules": "Four queens per player on a 10 by 10 board. Player 1 starts at A4,D1,G1,J4; Player 2 at A7,D10,G10,J7. Move a queen any unobstructed distance horizontally, vertically or diagonally, then shoot an arrow from its destination along another unobstructed queen line. The arrow permanently blocks its square; it can land on the square just vacated. Complete both steps as one turn. A player with no queen move loses. JSON move uses numeric zero-based row-major from/to and amount for the arrow, 0\u201399. Exact legal wire actions are supplied to the active player." },
+  { "id": "lines-of-action", "name": "Lines of Action", "symbol": "\u25CF", "players": "2 players", "description": "Bring your scattered stones together in a tactical race for connection.", "rules": "Claude Soucie\u2019s 8 by 8 connection game. Player 1 has six stones on each horizontal edge, Player 2 six on each vertical edge, with corners empty. Move any stone in one straight line exactly as many squares as there are stones of either color on that entire line. Jump over friendly stones but never enemies. Capture an enemy at the destination; never land on a friendly stone. Connect all your remaining stones into one group using orthogonal or diagonal adjacency to win; a single stone is connected. This edition awards simultaneous connection to the mover. An immobile player passes automatically; both immobile or three repetitions with the same player to move draw. This bounded-table edition also draws after 512 moves without connection. JSON move uses numeric row-major from/to, 0\u201363. Exact legal actions are listed." },
+  { "id": "last-greenhouse", "name": "The Last Greenhouse", "symbol": "\u2667", "players": "2 players \xB7 cooperative", "description": "Two private journals. Five locked rooms. Save the last seed bank together.", "rules": "An original cooperative escape-room story for two keepers. Read your private journal and compare it with your partner\u2019s observation to solve each room. Share publishes your current observation to both players; Pass hands the controls to your partner; Choose selects setting at 0\u20133 from the visible room options. Every action hands over the controls. Wrong answers are safe to retry and are included in the legal-action list. Complete the atrium, prism gallery, seed archive, pump room and dawn canopy together. Only your own private journal and shared notes are projected; spectators see no private journal. Local handoff conceals journals between turns. No competitive rating or Quick Play." },
+  { id: "euchre", name: "Euchre", symbol: "J", players: "4 players \xB7 2 teams", description: "Call trump, trust your partner, or take all five tricks alone.", rules: "Four players in opposite-seat partnerships. A 24-card deck uses 9 through ace. Each player receives five cards and one card is turned up. Starting left of dealer, order the turned suit or pass. If ordered, the dealer picks up the upcard and discards one card face down. After four passes, call any other suit; four more passes produce a fresh deal with the next dealer. A caller may go alone: their partner sits out. Left of dealer leads, skipping a sitting partner. Follow suit when possible. The trump jack is highest, followed by the other jack of the same color (the left bower, which belongs to trump), then A,K,Q,10,9 of trump. Other suits rank A,K,Q,J,10,9. Trick winner leads. Makers score 1 for three or four tricks, 2 for all five together, or 4 for all five alone. Defenders score 2 if makers take fewer than three. First team to 10 wins. No stick-the-dealer, joker or defensive lone hands. Hands and kitty remain private. Legal actions are enumerated for the active seat." },
+  { id: "cribbage", name: "Cribbage", symbol: "121", players: "2 players", description: "Choose your crib. Peg the count. Race to 121.", rules: "Two-player six-card cribbage with a standard deck. Aces are low. Each player discards two cards face down to the dealer's crib; the starter is revealed after both discard. A starter jack gives the dealer two points. Non-dealer leads pegging: play one card without exceeding 31, or say Go only when no card fits. Fifteen and thirty-one score two; consecutive pairs, triples and quads score two, six and twelve; the longest trailing run scores its length. The last card before a reset scores one except at 31. After a Go/reset the opponent of the last player leads if holding cards. Count non-dealer's hand, dealer's hand, then crib: fifteens, pairs, longest runs with multiplicities, four/five-card hand flushes, five-card-only crib flush, and one for a jack matching the starter's suit. Counting is automatic; no muggins. Dealer alternates. First to reach 121 at any scoring event wins immediately. Hidden cards and crib stay private until counting; spectators see only public cards. Exact legal JSON actions are supplied in visible_state.legalActions for the active player." },
+  { id: "fanorona", name: "Fanorona", symbol: "\u2194", players: "2 players", description: "Approach or withdraw. One move can capture a whole line.", rules: "Two players on the traditional 9 by 5 connected-point board, twenty-two stones each. Player 1 starts. Move one stone along a drawn line to an adjacent empty point. Captures are compulsory when available: approach captures the consecutive enemy line beyond the destination; withdrawal captures the consecutive enemy line behind the starting point. Choose one when both apply. After a capture you may continue with the same stone or Stop. A capture sequence cannot revisit a point or repeat the immediately preceding direction. A non-capturing move is allowed only when no capture exists. Capture every opposing stone or leave the opponent without a move to win. This implementation draws at three repetitions of the same position with the same player to move, or eighty completed turns without a capture. Intersections are zero-based row-major: top-left 0, bottom-right 44. JSON move uses from/to plus amount 0 for approach or a quiet move, 1 for withdrawal; stop ends an optional continuation. Exact legal actions are supplied in visible_state.legalActions." },
+  { "id": "categories", "name": "Categories", "symbol": "A\u2013Z", "players": "2\u20138 players", "description": "One letter. Six categories. Race your friends to a unique answer.", "rules": "Five English-language rounds with Country, City, Animal, Food, Occupation and Object. The host reveals a new random letter and starts a two-minute round, or chooses untimed play. Submit one locked answer sheet; blank answers are allowed. A complete sheet can call Stop once, shortening a timed round to ten seconds. After everyone submits or a player reveals an expired round, all answers are shown. Unsubmitted answers are blank. Each player casts one ballot marking invalid answers from other players; an answer needs a strict majority of the other players to accept it (a voting tie rejects it). Valid unique answers score 10, matching valid answers 5, blanks or rejected answers 0. Highest total after five rounds wins; equal totals draw. Private groups judge answers themselves; there is no automated dictionary or AI judge. Local play uses untimed private handoffs." },
+  { "id": "cheat", "name": "Cheat", "symbol": "?!", "players": "3\u20136 players", "description": "Play face down. Tell a convincing story. Call the bluff.", "rules": "Deal all 52 cards clockwise. Player 1 claims aces, then claims cycle through 2 to king and back to ace. On your turn place one to four cards face down, claiming the required rank; bluffing is allowed. Before the next play, any other player may challenge, or the next player may accept. A challenge reveals only the latest cards: if any is the wrong rank the claimant takes the whole pile; otherwise the challenger takes it. Accepted cards stay hidden. The next clockwise player then takes their turn with the next required rank. An empty hand wins only after its final claim is accepted or survives a challenge. This table uses an explicit challenge window without a reaction timer." },
+  { "id": "president", "name": "President", "symbol": "3\u21922", "players": "3\u20136 players", "description": "Beat the group. Pass at the right moment. Finish first.", "rules": "A single deal with a standard 52-card deck, all cards dealt clockwise. Ranks rise from 3 through ace, with 2 highest. The holder of 3 of clubs opens with a group containing it. Lead one to four equal-rank cards; following plays must contain the same number of cards at a strictly higher rank. You may pass, but cannot re-enter until that pile clears. When all other active players pass, the last player to play leads again; if they have finished, the next active player leads. Finishers leave play and receive places in order. Play continues until one player remains; the first finisher is President. No jokers, suit tie-breaks, special twos, revolution or between-deal tribute." },
+  { "id": "rummy", "name": "Classic Rummy", "symbol": "777", "players": "2\u20134 players", "description": "Draw a card. Build sets and runs. Empty your hand.", "rules": "One deal, no jokers. Two players receive ten cards each; three or four receive seven. Aces are low only. Draw one card from the stock or take the top discard. Then optionally meld sets of three or four equal ranks, or runs of three or more consecutive cards of one suit. You may add held cards to either end of any public run or complete a public set. Keep at least one card and end your turn by discarding; a taken upcard cannot be discarded immediately. First to discard their last card wins and scores the total value of cards held by opponents: ace 1, faces 10, other cards face value. Recycle discards beneath the top card when stock runs out. If stock and recyclable discards are both empty and the next player chooses stock, the deal ends; lowest remaining card value wins, with ties drawn. No initial meld threshold, knock or Rummy 500 scoring." },
+  { id: "tic-tac-toe", name: "Tic-tac-toe", symbol: "XO", players: "2 players", description: "Nine squares. Three in a row. Your next quick match.", rules: "X starts on a 3 by 3 board. Take turns placing your mark on an empty square. Three marks in a horizontal, vertical or diagonal line wins. A full board without a winner draws." },
+  { id: "international-draughts", name: "International Draughts", symbol: "\u265B", players: "2 players", description: "Twenty pieces. Flying kings. Capture the longest chain.", rules: "White starts on a 10\xD710 board with twenty pieces per side. Men move one diagonal square forward and capture in either direction. Kings slide diagonally and land on any empty square beyond a captured piece. Captures are compulsory: choose a sequence taking the greatest number of pieces. Captured pieces remain as blockers until the entire sequence ends. A man becomes a king only if its final square is on the promotion row. No pieces or no legal move loses. Threefold repetition, twenty-five successive king moves per player without captures or man moves, and the official sixteen/five-move king endgame limits draw automatically." },
+  { id: "atomic-chess", name: "Atomic Chess", symbol: "\u265C", players: "2 players", description: "Every capture explodes. Protect your king from the blast.", rules: "Standard chess setup and moves, with explosive captures: the capturing piece, captured piece and adjacent non-pawns disappear. Adjacent pawns survive. En passant explodes at the capturing pawn\u2019s destination. A move that explodes your own king is illegal. Kings cannot capture, but may stand next to one another. Explode the opposing king or deliver checkmate to win. Stalemate, insufficient material, threefold repetition or fifty moves without a pawn move or capture draws. Castling and all four promotions are supported." },
+  { id: "three-check", name: "Three-check", symbol: "\u2654", players: "2 players", description: "Give three checks to win. Every threat counts.", rules: "Standard chess rules, plus a second way to win: give your opponent check three times. A double check counts as one checking move. Checkmate also wins. Each player\u2019s checks are shown beside the board. Standard castling, en passant and all four promotions apply. Stalemate, insufficient material, threefold repetition or fifty moves without a pawn move or capture draws." },
+  { id: "connect-four", name: "Connect Four", symbol: "\u25CF", players: "2 players", description: "Drop a piece. Connect four. Watch the next column.", rules: "Two players alternate dropping pieces into one of seven columns on a six-row board. Each piece falls to the lowest empty space. Four or more pieces of your color in a horizontal, vertical or diagonal line wins. A full board without a winner draws." },
+  { id: "dots-boxes", name: "Dots & Boxes", symbol: "\u25A6", players: "2 players", description: "Complete a square. Claim another turn.", rules: "Players alternate drawing one unused edge on a 3 \xD7 3 box board. Completing the fourth side of a box claims it and gives another turn. An edge can complete two boxes. When all nine boxes are owned, most boxes wins. All information is public." },
+  { id: "battleships", name: "Battleships", symbol: "\u2693", players: "2 players", description: "Hide your fleet. Read the hits. Find the last ship.", rules: "Each player secretly places five straight ships of lengths 5, 4, 3, 3 and 2 on a 10\xD710 grid. Ships may touch but cannot overlap or leave the grid. Tap a starting square to place the next ship; switch horizontal/vertical or arrange automatically, then lock the fleet. Player 1 sets up first, then Player 2. Player 1 fires first. Take exactly one shot per turn, including after a hit. The target grid marks hits and misses, and reveals a ship when every square is hit. Sink all five enemy ships to win. On one device, hide your fleet before passing it. Online, only your own ships and already-known shot results are sent to your browser." },
+  {
+    id: "thousand",
+    name: "Thousand",
+    symbol: "1000",
+    players: "2\u20134 players",
+    description: "Bid your hand. Marry a new trump.",
+    rules: "A 24-card deck, nine through ace; strength is nine, jack, queen, king, ten, ace. Three active players receive seven cards and a three-card kitty. With four seats the dealer sits out and scores revealed kitty aces (50 each) and marriages. Two players receive ten cards each and choose one of two two-card kitties. The first active player opens at 100; bid in tens, no higher than 120 plus held marriages. Winner takes a kitty, gives each other active player a card (or discards two with two seats), then declares at least the auction bid. Follow suit and beat the winner when possible; if void, trump when held. Leading a held queen-king pair with the marriage declaration earns clubs 60, diamonds 80, hearts 100 or spades 40 and changes trump. Card points: ace 11, ten 10, king 4, queen 3, jack 2. Remaining kitty cards score for the last trick winner. Declarer makes or loses their contract; others round their points to tens. At 800, only declarer earns further points. First to 1000 wins, with declarer winning a simultaneous finish. The first bomb cancels freely; subsequent bombs award opponents 60 (40 with four seats). Four nines can request a redeal."
+  },
+  {
+    id: "binokel",
+    name: "Binokel",
+    symbol: "AA",
+    players: "4 players",
+    description: "Four copies. Two partners. One contract.",
+    rules: "Partners sit opposite. Four copies of jack, queen, king, ten and ace in every suit form an 80-card deck; twenty cards each. Auction starts at 50, rises by one below 60 and by five thereafter. Passed players leave the auction. If the first three pass, dealer plays 50. Declarer chooses trump only from a held queen-king pair; no pair loses the contract. The declaring partnership needs at least 20 meld points. Melds score automatically and their cards are revealed: aces/kings/queens/jacks around; ordinary and royal marriages; spade queen with diamond jack; and a trump A-10-K-Q-J run. Duplicate melds use the full single/double/triple/quadruple table. A royal marriage already in a run is not counted twice. Follow suit and beat the current winner when possible; when void, trump and overtrump when possible. Equal copies favor the first played. Each ace, ten or king taken earns one; last trick earns two. At least 20 trick points are required to score a hand, and at least 20 meld points to add melds. Declarers reaching their bid score their total, otherwise lose the bid. Opponents score qualifying totals. First team to 500 wins; if both reach 500, the declaring team wins."
+  },
+  {
+    id: "skat",
+    name: "Skat",
+    symbol: "J",
+    players: "3 players",
+    description: "Win the bidding duel. Play alone against two.",
+    rules: "Thirty-two cards, seven through ace. Middlehand speaks values to forehand, who holds or passes; rearhand then speaks to the survivor. If both speakers pass without a bid, forehand plays 18 or passes out. Declarer picks up the two-card skat and discards two, or plays from hand. Choose a suit, Grand (only jacks trump) or Null (lose every trick). Jacks rank clubs, spades, hearts, diamonds above suit trumps. Other suit/Grand cards rank A-10-K-Q-9-8-7; Null ranks A-K-Q-J-10-9-8-7. Follow the effective suit; jacks belong to trump in suit/Grand games. Forehand always leads. Suit/Grand need 61 card points, including skat; Null ends in loss on declarer\u2019s first trick. Value multiplies suit base (diamonds 9, hearts 10, spades 11, clubs 12, Grand 24) by matadors, game, hand and Schneider/Schwarz/open levels. Hand games can announce 90 points or all tricks. Null values are 23, hand 35, open 46, open hand 59. Lost or overbid games subtract twice their value, rounding overbids up to a sufficient base multiple. Highest score after eighteen hands wins. No Ramsch, Kontra or tournament bonus variant."
+  },
+  {
+    id: "baska",
+    name: "Baska",
+    symbol: "DQ",
+    players: "4 players",
+    description: "Find your hidden partner in sixteen cards.",
+    rules: "The red (heart-ace) variant, sixteen cards: ace, ten, queen and jack in each suit. Trump strength: heart ace, heart ten, queens clubs-spades-hearts-diamonds, jacks in that order, diamond ace, diamond ten. Other cards keep their printed suits. Old partners hold club and spade queens; holding both creates a silent solo. Wedding pairs that holder with the first available club, spade or heart jack holder. Auction offers Grand, Zolo and their all-trick Du contracts, with alternating counters up to redouble. Grand has only jack trumps. Four tens, aces or queens automatically claim Zolo Bieda, Master or Baska. Follow suit and beat the winner when possible. Card points are A11, 10=10, Q3, J2. Old side needs 53; with 52\u201352, the side that last countered loses. Ordinary/wedding stakes rise for failure to reach 26 (young) or 27 (old), or failure to take a trick; old losses cost twice. Silent solo stakes four, Grand/Zolo five, Du/honor ten, all doubled by counters. Paired winners gain the stake each; a solo winner gains it from each opponent; highest total after sixteen hands wins. Black and three-tens variants are outside this table."
+  },
+  {
+    id: "canasta",
+    name: "Canasta",
+    symbol: "77",
+    players: "2 or 4 players",
+    description: "Build seven-card melds. Break a frozen pile.",
+    rules: "Two 54-card decks, including four jokers. Two players get fifteen cards and draw two; four players get eleven and draw one, sharing melds with the opposite partner. Meld matching natural ranks with at least two natural cards and at least three total; at most three wild twos/jokers, with no more wild than natural. Seven or more cards form a canasta. Opening melds total 15 below zero score, 50 below 1500, 90 below 3000, then 120. Take the entire discard pile only by immediately melding its top; a frozen pile requires two matching natural cards held. Wild cards block pickup and freeze the pile; black threes block pickup except a final meld. Red threes are set aside and replaced when drawn from stock. Black threes meld only when going out. End a turn by discarding one. Going out requires two canastas with two players, one with partners; premature going out loses the match. Natural canastas earn 500, mixed 300; going out 100, concealed opening 200. Red threes earn 100 each plus 400 for all four, negative without a meld. Melded cards score positive, held cards negative. Card values: joker50, A/2=20, 8\u2013K=10, others5. Highest score reaching 5000 wins. Optional partner permission is not required."
+  },
+  {
+    id: "bridge",
+    name: "Bridge",
+    symbol: "NT",
+    players: "4 players",
+    description: "Bid a contract. Plan two hands together.",
+    rules: "Partners sit opposite. A sixteen-board match uses standard duplicate contract scores and the rotating vulnerability cycle. Each player has thirteen cards. Bids increase by level and strain: clubs, diamonds, hearts, spades, no trump. Three passes after a bid end the auction; four opening passes pass out the board. Opponents may double; the declaring side may redouble. Declarer is the first player in the winning partnership to bid the final strain. The player to declarer\u2019s left leads. Dummy is exposed after that lead and declarer controls its plays. Follow suit when possible; highest trump or lead-suit card wins. Contract, game, slam, overtrick and undertrick scores account for doubling and vulnerability. Highest net team score after sixteen boards wins. This table uses raw duplicate scores; Kurnik\u2019s HCP-adjusted IMP table, conventions, claims and tournament director rulings are outside this variant."
+  },
+  {
+    id: "polish-hearts",
+    name: "Polish Hearts",
+    symbol: "\u2665",
+    players: "3\u20134 players",
+    description: "Avoid seven penalties, then win points back.",
+    rules: "Seven penalty hands: each trick costs 20; each heart 20; queen 60; king or jack 30; heart king 150; seventh and last tricks 75 each; the seventh hand combines all penalties. Follow suit, with no obligation to beat the current winner. Hearts cannot lead while another suit is held in the heart, heart-king and combined hands. Next, each player deals a trump hand and chooses trump from the first five cards, before the rest are dealt; each trick earns 25. Finally, build four suit columns around the dealer\u2019s opening rank; extend a column by one rank, or start another at that opening rank. Play whenever possible. First out earns 800, second 500. Three-player games omit the club two, use six cards for the trump choice, cost 15 per trick, 140 for the heart king and 70 per special trick, earn 20 per trump trick and award 790/485 for the final layout. Highest total wins."
+  },
+  {
+    id: "durak",
+    name: "Durak",
+    symbol: "\u2660",
+    players: "2\u20134 players",
+    description: "Beat the attack. Empty your hand.",
+    rules: "Individual throw-in Durak with 36 cards, six through ace. Deal six each; the bottom stock card shows trump and is drawn last. The lowest dealt trump holder opens. Attack with one card, then add ranks already on the table, including defended ranks. The defender beats a card with a higher card of the same suit or any trump over a nontrump. Attacks are capped at six cards or the defender\u2019s starting hand size. The main attacker has first priority; finishing offers other attackers a clockwise turn. Taking opens a final throw-in window, then the defender collects all table cards and skips their next attack. Successful defense discards the table and the defender attacks next. Refill the main attacker first, other players clockwise and defender last. Empty hands leave once the stock runs out. The last player holding cards loses; simultaneous empty hands draw. This table has no transfer attacks, teams or optional trump-six exchange."
+  },
+  {
+    id: "makao",
+    name: "Makao",
+    symbol: "Q",
+    players: "2\u20134 players",
+    description: "Match suits and ranks. Counter the demand.",
+    rules: "Five cards each from a 52-card deck. Match the pile\u2019s suit or rank, or play a queen on an ordinary card; any ordinary card fits a queen. Groups of the same rank can be played together, with the first card matching. Twos and threes add draw penalties; the heart king adds five to the next player, the spade king to the previous player. Penalties can be stacked with any fighting card. Fours add waiting turns, countered with fours. Jacks request an ordinary rank for one complete cycle, or cancel a request; aces request a suit for the next player. Queens do not override demands. A normal draw offers only that new card for immediate play. Say Makao with the checkbox when one card remains; the next player can catch a missed declaration for five cards. When both stock and reusable discards run out, every player returns a random half of their hand, rounded down. The first empty hand wins. No jokers or sequence-chain variant."
+  },
+  {
+    id: "three-five-eight",
+    name: "3-5-8",
+    symbol: "358",
+    players: "3 players",
+    description: "Meet your quota. Exchange for stronger cards.",
+    rules: "Eighteen hands with a 52-card deck. Sixteen cards each and a four-card kitty. Dealer targets eight tricks, the next player five, the third three. Each player chooses each of the six contracts once on their own deals: four trump suits, no trump and no tricks. Discard four before taking the kitty. Follow suit; if void, play trump when held. Highest trump or highest lead suit wins. Ordinary hands score tricks minus quota; no-tricks reverses that score. Before subsequent hands, players above their previous quota exchange one unwanted card per surplus trick with players below quota; the receiver automatically returns their highest card in its suit. Higher current quotas exchange first. Highest total after eighteen hands wins. This uses the eighteen-hand contract variant rather than the twelve-trick sudden-win variant."
+  },
+  {
+    id: "property-trading",
+    name: "Property Trading",
+    symbol: "\u2302",
+    players: "2\u20134 players",
+    description: "Build a garden estate. Bargain for a complete street.",
+    rules: "An original forty-space estate board with classic property trading rules. Each player starts with 1,500 points; passing Start earns 200. Roll two dice, buy unowned properties or auction them to all players. Doubles earn another roll; three consecutive doubles send you to jail. Collect rents, complete color groups and build evenly using the finite bank of 32 houses and 12 hotels. Mortgage unbuilt properties for half their price; redeem for 60%. Trade unbuilt properties and cash by an explicit offer and acceptance; receiving a mortgaged property costs 10% of its price. Jail ends with doubles, a release card or a payment of 50; the third failed roll forces payment. Income tax is 200 or 10% of estate value; luxury tax is 75. Free Park pays nothing. Resolve debts by selling buildings or mortgaging assets; bankruptcy transfers an estate to the creditor, or auctions it for bank debts. The last solvent player wins. Free points only."
+  },
+  {
+    id: "draw-guess",
+    name: "Draw & Guess",
+    symbol: "\u270E",
+    players: "2\u201320 players",
+    description: "A private word. A shared sketch.",
+    rules: "Take turns drawing one of three private English prompts. You have two minutes. Other players guess while the drawing updates. A correct guess earns 1\u201345 points based on remaining time, and the drawer earns up to five more, capped at 45, for that guess. Each player can score once per round. If everyone guesses, the round ends early. No correct guesses costs the drawer ten. First to 100 ends the match; highest score wins. Draw pictures rather than writing the word. Local play offers a player switch and hides the prompt from guessers."
+  },
+  {
+    id: "letter-tiles",
+    name: "Letter Tiles",
+    symbol: "A",
+    players: "2\u20134 players",
+    description: "Build a crossword. Make every letter count.",
+    rules: "American English Scrabble-style home scoring on the standard 15 \xD7 15 premium-square layout, with 100 tiles and seven per rack. First word: at least two letters covering the center double-word square. Place connected tiles in one row or column without gaps; every new or crossed word scores, including existing letters. English values: A E I L N O R S T U 1; D G 2; B C M P 3; F H V W Y 4; K 5; J X 8; Q Z 10. Blanks stay zero and keep their chosen letter. DL/TL multiply each newly placed letter; DW/TW multiply its whole word after letter bonuses. New premiums apply to every word using that tile, once on its placement turn; multiple word multipliers multiply together. Using seven new tiles adds 50 after all multipliers. Next player accepts or challenges against our ENABLE English word-game list with QI/ZA additions; accepted words differ from official NWL/Collins lists. Invalid words return the tiles and lose the proposer\u2019s turn; a failed challenge loses the challenger\u2019s next turn. Exchange any number of rack tiles as often as needed, using a turn, when at least seven remain in the bag. Everyone passing twice ends play, as does emptying a rack with an empty bag. Deduct unplayed tiles; the player going out also receives opponents\u2019 deductions. Highest final score wins; a final tie favors the higher pre-adjustment score. Earlier rounds retain their original rules until restarted."
+  },
+  {
+    id: "pan",
+    name: "Pan",
+    symbol: "\u2667",
+    players: "2\u20134 players",
+    description: "Shed your cards before the pile turns.",
+    rules: "A 24-card deck, nine through ace. The holder of the heart nine opens with that card or all four nines. Play one card or all four of a rank, no lower than the pile top. With only the heart nine on the pile, the other three nines can be played together. Instead of playing, take up to three top cards, leaving the heart nine. Empty hands leave the round. The last player receives a P, then A, then N; three letters loses the match. A last player who can immediately shed one or four aces draws the round. This table uses the ordinary clockwise variant."
+  },
+  {
+    id: "gin-rummy",
+    name: "Gin Rummy",
+    symbol: "\u2666",
+    players: "2 players",
+    description: "Build runs and sets. Know when to knock.",
+    rules: "Ten cards each. The dealer\u2019s opponent may take the opening upcard; if passed, the dealer may take it. If both pass, draw from stock. Draw one, then discard another; you cannot return the upcard just drawn. Meld sets of three/four equal ranks or same-suit runs of at least three, ace low. Knock when the remaining deadwood is at most ten: ace one, face cards ten. Melds and opponent layoffs are optimized automatically. Gin earns deadwood difference plus 25; an equal or lower opponent deadwood undercuts for 25 plus difference. At 100, the game ends with game and hand bonuses. Two cards left in stock cancels the round with the same dealer."
+  },
+  {
     id: "sixty-six",
     name: "Sixty-Six",
     symbol: "\u2654",
     players: "2 players",
     description: "Claim sixty-six. Close the stock with care.",
-    rules: "Six cards each from a 24-card deck. Rank order: nine, jack, queen, king, ten, ace; values 0, 2, 3, 4, 10, 11. While stock is open, play freely; trick winner draws first. Exchange trump nine after winning a trick. Before leading, you may close the stock; then follow suit, overtake if possible, otherwise trump. A queen\u2013king marriage declared while leading with open stock earns 20, or 40 in trump, after a subsequent won trick. Claim 66 before leading, or immediately with a marriage. False claims or failed closure award the opponent 2/3 match points. Otherwise round wins earn 1\u20133 based on opponent points. An unclosed last trick adds ten. First to seven match points wins."
+    rules: "Six cards each from a 24-card deck. Rank order: nine, jack, queen, king, ten, ace; values 0, 2, 3, 4, 10, 11. While stock is open, play freely; trick winner draws first. Exchange trump nine after winning a trick. Before leading, you may close the stock; then follow suit, overtake if possible, otherwise trump. A queen\u2013king marriage declared while leading with open stock earns 20, or 40 in trump, once you have won a trick (including the one it leads). Claim 66 before leading, or immediately with a marriage. False claims or failed closure award the opponent 2/3 match points. Otherwise round wins earn 1\u20133 based on opponent points. An unclosed last trick adds ten. First to seven match points wins."
   },
   {
     id: "spades",
@@ -4395,338 +4971,186 @@ var action_catalog_default = {
     "move",
     "stop"
   ],
-  euchre: [
-    "pass",
-    "trump",
-    "discard",
-    "play",
-    "next"
-  ],
-  amazons: [
-    "move"
-  ],
-  "lines-of-action": [
-    "move"
-  ],
-  "last-greenhouse": [
-    "share",
-    "pass",
-    "choose"
-  ]
-};
-
-// lib/agents/action-help.ts
-var help = {
-  amazons: "move: numeric from/to 0\u201399 and amount for the arrow square. Select an exact legal_wire_actions entry.",
-  "lines-of-action": "move: numeric from/to 0\u201363. Move the count of all stones along the full line; enemy stones block jumping.",
-  "last-greenhouse": "share: publish your current private journal observation. pass: hand controls to partner. choose: at 0\u20133 selects a room setting. All choices are listed, including incorrect answers. Cooperate using both journals.",
-  euchre: "Use visible_state.legalActions. trump: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades; promotion alone optionally sits your partner out. pass declines trump. discard/play: at is a held card ID, not a hand index. IDs are suit*6+rank, ranks 0\u20135 mean 9,10,J,Q,K,A. The left bower belongs to trump for following suit. next deals after a hand. Partners are opposite seats; first team to 10 wins.",
-  cribbage: "Use visible_state.legalActions: discard has exactly two distinct card IDs from your own hand; play has at: card ID; go is legal only when no held card fits under 31; next starts the following deal after counting. Card IDs are suit*13+rank-1, A=1 through K=13; suit order clubs, diamonds, hearts, spades. Crib and opponents' unplayed cards remain hidden.",
-  fanorona: "Use visible_state.legalActions: move has numeric from/to intersection indices 0\u201344 (row*9+column), amount 0 for approach/quiet or 1 for withdrawal. stop ends an optional capture continuation. Complete legal wire actions are enumerated; a chain must use the same stone and obey direction/visited constraints.",
-  categories: `begin: host starts a timed round; promotion:'untimed' disables the timer. submit/stop: text is a string holding a JSON array of six English answers in category order, for example text set to the string '["Apple","Ant",...]' (not a raw array); stop needs a complete sheet. expire reveals a timed-out round. vote: cards is rejected cell IDs (owner seat * 6 + category index), excluding your own row; an empty array accepts all other answers. next: host advances. Answers and ballots lock once submitted. Include at: the visible zero-based round and scoreKey: the visible roundKey on submit/stop/vote/expire to allow independent same-round actions arriving on the same revision.`,
-  cheat: "play: cards is one to four card IDs from your hand, claiming the displayed rank. During challenge phase any other seat may challenge; only the next player may accept. Final-card claims must resolve before a win.",
-  president: "play: cards is one to four equal-rank card IDs. Match pile size and beat its rank; 2 is high. Opening group includes 3 of clubs. pass sits out until the pile clears. Finished seats leave play; order gives final places.",
-  rummy: "stock/upcard: draw first. meld: cards is a set or run of held card IDs. layoff: at is a public meld index, cards is held card IDs to add. discard: at is a held card ID. Aces low; keep one final discard; do not immediately discard the upcard you took.",
-  "connect-four": "place: at is a zero-based column (0\u20136). Convenience: --column 1\u20137.",
-  "tic-tac-toe": "place: at is a zero-based row-major square (0\u20138). legal_actions use one-based row/column instead; pass either form.",
-  chess: "move: from/to are algebraic squares; promotion is q/r/b/n.",
-  "atomic-chess": "move: from/to are algebraic squares; promotion is q/r/b/n. Explosions follow the game rules.",
-  "three-check": "move: from/to are algebraic squares; promotion is q/r/b/n. Check counts are in visible_state.",
-  checkers: "move: from/to are zero-based row-major squares (0\u201363); continue a mandatory capture chain. Convenience flags use algebraic squares.",
-  "brazilian-checkers": "move: from/to are zero-based squares (0\u201363); maximum captures apply.",
-  "international-draughts": "move: from/to are zero-based squares (0\u201399). sequence: cards is a complete legal path of square indexes, including the origin.",
-  reversi: "place: at is a zero-based row-major square (0\u201363). Unavailable turns pass automatically.",
-  gomoku: "place: at is a zero-based row-major intersection (0\u2013224). Exactly five wins.",
-  hex: "place: at is a zero-based row-major hexagon. swap: no payload, only the second seat's first turn. Convenience: --row/--column or --swap.",
-  "dots-boxes": "place: at is a zero-based edge index; legal_actions and --edge use the same edge one-based (edge N is visible_state.edges[N-1]). Horizontal edges precede vertical edges in row-major order. Edges and box owners are in visible_state. Convenience: --edge is one-based.",
-  oware: "sow: at is a zero-based pit index, 0\u20135 for seat 0 and 6\u201311 for seat 1. Convenience: --pit is one-based.",
-  go: "place/dead: at is a zero-based row-major intersection (board_labeled shows row start indexes). pass/resume: no payload. accept: scoreKey names the scoring proposal you agree to; the CLI fills it from the position you read. Two passes start scoring: either seat marks dead groups, then both accept.",
-  battleships: "auto/clear/ready: no payload. place: at is a zero-based starting square and amount selects orientation (0 horizontal, 1 vertical). fire: at is a zero-based target square. Inspect your fleet/setup phase; enemy ships remain hidden.",
-  mills: "place/capture: at is a zero-based point index. move: from is the origin and at the destination. Completing a mill requires a subsequent capture action.",
-  dice: "roll: no payload. hold: at is a die index (0\u20134) to toggle its hold after rolling. score: at is a category index. Inspect the roll phase and score sheet.",
-  ludo: "roll: no payload. move: at is the index (0\u20133) of your token. Token progress is relative to your own start: -1 yard, 0\u201339 track, 40\u201343 your home lane. Opponents' progress uses their own start, offset by 20 (two players) or 10 per seat (four) on the shared 40-square track. A 6 leaves the yard and keeps the turn.",
-  domino: "tile: at is your zero-based hand position (not a pip value) and amount selects the chain end: 0 left, 1 right. draw: draw until you can play, or pass when the stock is empty. next: start the following round. Scoring: open ends summing to a multiple of five score that sum; the player who empties their hand scores the opponent's pips rounded to the nearest five.",
-  football: "place: at is a zero-based destination point. The state records ball, used edges and continuing rebounds.",
-  backgammon: "roll: no payload. move: numeric from/to and amount (die value), one die per action. Points are 0\u201323. Positive point counts are seat 0, negative seat 1. Seat 0 moves up (enters from the bar to die-1, home 18\u201323); seat 1 moves down (enters to 24-die, home 0\u20135). from -1 means the bar; to 24 bears off for both seats. Compulsory dice usage is enforced.",
-  shogi: "move: from is a zero-based square or a hand-piece type for a drop; to is a zero-based square; promotion:'yes' promotes. Inspect your hands and piece owners.",
-  xiangqi: "move: numeric zero-based row-major from/to on the 9\xD710 board. promotion is unused.",
-  poker: "fold/check/call/next: no payload. raise: amount is the desired bet total. Follow phase, pot, current bet, your cards and stack. next is a between-hand host action.",
-  durak: "play: at is your card ID from the visible hand; take/pass: no payload. Follow attack/defence roles and visible trump/table.",
-  makao: "play: cards is 1\u20134 card IDs from your visible hand, all of the same rank. amount chooses an ace suit (0 clubs, 1 diamonds, 2 hearts, 3 spades) or a jack demand (rank 5\u201310 or 13 for king; 0 for no demand); visible_state.suit and demand use the same numbers; promotion:'makao' announces the last card. draw/pass/catch act according to phase. Inspect drawn-card and demand state.",
-  pan: "play: cards is an array of card IDs from the visible hand; take/next: no payload. Follow the table rank and legal group rules.",
-  "gin-rummy": "stock/upcard/pass/next: no payload. discard/knock: at is a card ID from the visible hand. Inspect draw/discard phase and deadwood rules.",
-  "sixty-six": "play: at is a card ID from the visible hand; promotion:'marriage' or 'marriage-claim' declares. exchange/close/claim/next are phase-specific commands.",
-  hearts: "select: at is a card ID from the visible hand for passing, then pass. play: at is a card ID from the visible hand. moon: amount selects a scoring choice. Follow phase, lead suit and legal cards.",
-  spades: "bid: amount is the bid; blind/look for blind nil where offered. play: at is a card ID from the visible hand. Follow partner, phase and lead suit.",
-  "oh-hell": "bid: amount is the bid. play: at is a card ID from the visible hand. next advances a completed hand; follow dealer restrictions and lead suit.",
-  "three-five-eight": "exchange: at is one card ID from your visible hand. discard: cards is exactly four distinct card IDs from your visible hand. play: at is one card ID from your visible hand. contract: amount 0\u20133 chooses a suit, 4 no trumps, 5 misere. next advances the hand.",
-  bridge: "bid: amount 1\u201335 encodes level floor((amount-1)/5)+1 and strain (amount-1)%5; pass/double/redouble have no payload. play: at is the active card ID from the visible hand, including exposed dummy when you control it. Follow auction, strain and lead-suit rules.",
-  "polish-hearts": "trump: amount is a suit index; pass: no payload, only when no layout card fits; play: at is a card ID from the visible hand. Follow the current penalty/trump/layout phase.",
-  thousand: "bid/declare: amount is points. kitty: at selects a kitty. exchange: cards is card IDs from the visible hand. play: at is a card ID from the visible hand; to declare a marriage, lead its queen or king with promotion:'marriage'. pass/bomb/redeal/next depend on phase. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades; ranks 9 through ace). next: the declarer deals the next hand.",
-  binokel: "bid: amount is points; trump: amount is a suit; play: at is a card ID from the visible hand. pass/next have no payload. Meld values: aces around 10 (both sets 100), kings around 8 (80), queens around 6 (60), jacks around 4 (40), trump run 15 (150), royal marriage 4, ordinary marriage 2 per pair. A bid is the team's trick points plus melds; tricks hold about 240 points per hand, so bids far above that rarely make. The declaring team needs 20 meld points.",
-  skat: "bid: amount is an auction value; hold/pass/hand/pickup act in auction/pickup phases (after a hold the bidder must bid higher or pass). discard: cards is exactly two card IDs from your visible hand. contract: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades as trump, 4 grand (jacks only), 5 null, with optional promotion normal/schneider/schwarz/ouvert. play: at is a card ID from the visible hand. Jacks rank clubs, spades, hearts, diamonds. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades). next: the previous declarer deals the next hand.",
-  baska: "announce: no payload in the honor phase. contract: amount is one of 1,3,4,5,6 and must exceed the current contract. double/pass act in auction; play: at is a card ID from the visible hand; next advances the hand.",
-  canasta: "stock/next: no payload. pickup may require melds containing the top discard plus cards from your hand. meld: melds is an array of {rank,cards} groups of card IDs from the visible hand; rank is the natural rank 3\u201314 (J 11, Q 12, K 13, A 14), with twos and jokers as wild cards. cards_labeled names each card. discard: at is a card ID from the visible hand. Follow opening meld and canasta requirements.",
-  "letter-tiles": "place: placements is an array of {at,rack,letter?}; at is a board index and rack a rack index, letter assigns a blank. exchange: cards is rack indexes. accept/challenge/pass/next depend on phase.",
-  "draw-guess": "choose: at selects one of your offered prompts. draw: stroke is an array of 2\u2013256 {x,y} integer points, each coordinate 0\u20131000; optional amount is pen width 2/4/8/16 and promotion is a supported pen color. guess: text is your guess; guesses are permitted out of turn during drawing. clear/expire/next depend on phase. Hidden prompts stay hidden from guessers.",
-  "property-trading": "roll/end/buy/auction/pay/bankrupt/pass/reject have phase-specific effects. bid: amount is the bid. mortgage/redeem/build/sell: at selects a property. tax: amount is 0 or 1. release: amount 0 pays fifty, 1 uses a release card. offer: tradeOffer contains seat,give,take,giveCash,takeCash; accept confirms the current trade."
+  euchre: [
+    "pass",
+    "trump",
+    "discard",
+    "play",
+    "next"
+  ],
+  amazons: [
+    "move"
+  ],
+  "lines-of-action": [
+    "move"
+  ],
+  "last-greenhouse": [
+    "share",
+    "pass",
+    "choose"
+  ]
 };
-function actionHelp(game) {
-  return { format: `game play --room CODE --revision R --action '{"type":"...",...}'`, indexing: "Board and hand-position indexes are zero-based. Card IDs are the actual values in visible_state, not offsets into a hand array. Convenience --row/--column/--edge/--pit flags are one-based. Inspect the exact player-visible state; do not guess hidden cards or board indexes.", game: help[game], validation: "action_types lists permitted command families, not currently legal moves. The server enforces phases, turns, ownership and legality. After a rejected or uncertain action read status again; never retry blindly." };
-}
 
-// lib/multiplayer/trick-cards.ts
-var cardSuit = (card2) => Math.floor(card2 / 13);
-var cardRank = (card2) => card2 % 13 + 2;
-var cardLabel = (card2) => `${["", "", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"][cardRank(card2)]}${["\u2663", "\u2666", "\u2665", "\u2660"][cardSuit(card2)]}`;
-var penalty = (card2) => cardSuit(card2) === 2 ? 1 : card2 === 49 ? 13 : 0;
-function first(s) {
-  return s.variant === "spades" ? s.dealer : (s.dealer + 1) % s.hands.length;
-}
-function deal(s, entropy2) {
-  const count = s.hands.length, size = s.variant === "oh-hell" ? Math.max(1, (count === 4 ? 13 : 17) - s.round) : 13, deck = shuffled(
-    Array.from({ length: 52 }, (_, i) => i),
-    entropy2
-  );
-  const hands = Array.from(
-    { length: count },
-    (_, i) => deck.slice(i * size, (i + 1) * size).sort((a, b) => a - b)
-  );
-  const t = {
-    ...s,
-    size,
-    hands,
-    stock: deck.slice(count * size),
-    trick: [],
-    lastTrick: [],
-    tricks: Array(count).fill(0),
-    penalties: Array(count).fill(0),
-    bids: Array(count).fill(null),
-    blind: Array(count).fill(false),
-    blindAsked: Array(count).fill(false),
-    selected: Array.from({ length: count }, () => []),
-    passed: Array(count).fill(false),
-    broken: false,
-    winner: null,
-    result: ""
-  };
-  t.trump = s.variant === "spades" ? 3 : s.variant === "oh-hell" && s.round > 0 ? cardSuit(t.stock[0]) : null;
-  t.phase = s.variant === "hearts" ? s.round % 4 === 3 ? "play" : "pass" : s.variant === "spades" && Math.abs(s.scores[0] - s.scores[1]) >= 200 ? "blind" : "bid";
-  t.turn = s.variant === "hearts" ? t.phase === "play" ? hands.findIndex((h) => h.includes(0)) : 0 : first(t);
-  return t;
-}
-function createTrickCards(variant, count, entropy2) {
-  if (!index(count - 2, 3) || variant !== "oh-hell" && count !== 4)
-    throw Error("Choose the required player count.");
-  return deal(
-    {
-      variant,
-      turn: 0,
-      dealer: Math.floor(draws(entropy2, 1)[0] * count),
-      round: 0,
-      size: 13,
-      phase: "bid",
-      hands: Array.from({ length: count }, () => []),
-      stock: [],
-      trick: [],
-      lastTrick: [],
-      tricks: [],
-      penalties: [],
-      bids: [],
-      blind: [],
-      blindAsked: [],
-      selected: [],
-      passed: [],
-      scores: Array(variant === "spades" ? 2 : count).fill(0),
-      bags: [0, 0],
-      trump: null,
-      broken: false,
-      winner: null,
-      result: ""
-    },
-    entropy2
-  );
-}
-function trickLegalCards(s) {
-  if (s.phase !== "play") return [];
-  const hand2 = s.hands[s.turn].filter((c) => c !== null), lead = s.trick[0];
-  if (lead) {
-    const suited = hand2.filter((c) => cardSuit(c) === cardSuit(lead.card));
-    if (suited.length) return suited;
-    if (s.variant === "hearts" && s.tricks.every((n) => n === 0)) {
-      const clean = hand2.filter((c) => !penalty(c));
-      if (clean.length) return clean;
-    }
-    return hand2;
-  }
-  if (s.variant === "hearts") {
-    if (s.tricks.every((n) => n === 0)) return hand2.includes(0) ? [0] : [];
-    if (!s.broken) {
-      const clean = hand2.filter((c) => cardSuit(c) !== 2);
-      if (clean.length) return clean;
-    }
-  }
-  if (s.variant === "spades" && !s.broken) {
-    const clean = hand2.filter((c) => cardSuit(c) !== 3);
-    if (clean.length) return clean;
-  }
-  return hand2;
-}
-function finish(s) {
-  if (s.variant === "hearts") {
-    s.scores = s.scores.map((n, i) => n + s.penalties[i]);
-    s.result = `Round penalties: ${s.penalties.join(" \xB7 ")}`;
-    if (s.scores.some((n) => n >= 100)) {
-      s.phase = "finished";
-      s.winner = best(s.scores.map((n) => -n));
-    } else s.phase = "round";
-  } else if (s.variant === "spades") {
-    const gains = [0, 0];
-    for (const team2 of [0, 1]) {
-      const seats2 = [team2, team2 + 2], bid = seats2.reduce((n, i) => n + s.bids[i], 0), taken = seats2.filter((i) => s.bids[i] !== 0).reduce((n, i) => n + s.tricks[i], 0);
-      gains[team2] = taken >= bid ? bid * 10 + Math.max(0, taken - bid) : -bid * 10;
-      const bags = Math.max(0, taken - bid) + seats2.filter((i) => s.bids[i] === 0).reduce((n, i) => n + s.tricks[i], 0);
-      s.bags[team2] += bags;
-      gains[team2] -= 100 * Math.floor(s.bags[team2] / 10);
-      s.bags[team2] %= 10;
-      for (const i of seats2)
-        if (s.bids[i] === 0)
-          gains[team2] += (s.tricks[i] === 0 ? 1 : -1) * (s.blind[i] ? 200 : 100);
-    }
-    s.scores = s.scores.map((n, i) => n + gains[i]);
-    s.result = `Team 1 & 3: ${gains[0]} \xB7 Team 2 & 4: ${gains[1]}`;
-    if (s.scores.some((n) => n >= 500 || n <= -200)) {
-      s.phase = "finished";
-      s.winner = best(s.scores);
-    } else s.phase = "round";
-  } else {
-    s.scores = s.scores.map(
-      (n, i) => n + (s.bids[i] === s.tricks[i] ? 10 + s.tricks[i] : 0)
-    );
-    s.result = `Tricks taken: ${s.tricks.join(" \xB7 ")}`;
-    const rounds = (s.hands.length === 4 ? 13 : 17) + s.hands.length - 1;
-    if (s.round + 1 >= rounds) {
-      s.phase = "finished";
-      s.winner = best(s.scores);
-    } else s.phase = "round";
-  }
-  s.turn = first(s);
-}
-function playTrickCards(s, type, at, amount, entropy2) {
-  if (s.phase === "finished") throw Error("This match is finished.");
-  if (type === "next" && s.phase === "round")
-    return deal(
-      { ...s, round: s.round + 1, dealer: (s.dealer + 1) % s.hands.length },
-      entropy2
-    );
-  const t = structuredClone(s), seat = s.turn, count = s.hands.length;
-  if (s.phase === "pass") {
-    if (type === "select" && at !== void 0 && s.hands[seat].includes(at)) {
-      const selected = t.selected[seat];
-      if (selected.includes(at))
-        t.selected[seat] = selected.filter((c) => c !== at);
-      else if (selected.length < 3) selected.push(at);
-      else throw Error("Select three cards.");
-      return t;
-    }
-    if (type !== "pass" || t.selected[seat].length !== 3)
-      throw Error("Choose three cards to pass.");
-    t.passed[seat] = true;
-    if (t.passed.every(Boolean)) {
-      const offset = [1, 3, 2][s.round % 4];
-      t.hands = t.hands.map(
-        (h, i) => h.filter((c) => !t.selected[i].includes(c))
-      );
-      t.selected.forEach(
-        (cards, i) => t.hands[(i + offset) % 4].push(...cards)
-      );
-      t.hands.forEach((h) => h.sort((a, b) => a - b));
-      t.selected = t.selected.map(() => []);
-      t.phase = "play";
-      t.turn = t.hands.findIndex((h) => h.includes(0));
-    } else t.turn = t.passed.findIndex((n) => !n);
-    return t;
-  }
-  if (s.phase === "blind") {
-    const eligible = s.scores[1 - seat % 2] - s.scores[seat % 2] >= 200;
-    if (type === "blind" && eligible) {
-      t.bids[seat] = 0;
-      t.blind[seat] = true;
-    } else if (type !== "look")
-      throw Error("Choose blind nil or look at your cards.");
-    t.blindAsked[seat] = true;
-    if (t.blindAsked.every(Boolean)) {
-      t.phase = "bid";
-      t.turn = first(t);
-      while (t.bids[t.turn] !== null) t.turn = (t.turn + 1) % count;
-    } else t.turn = (seat + 1) % count;
-    return t;
-  }
-  if (s.phase === "bid") {
-    if (type !== "bid" || amount === void 0 || !index(amount, s.size + 1))
-      throw Error("Choose a legal bid.");
-    if (s.variant === "oh-hell" && s.bids.filter((b) => b !== null).length === count - 1 && s.bids.reduce((n, b) => n + (b ?? 0), 0) + amount === s.size)
-      throw Error("The last bid cannot make the total equal the hand size.");
-    t.bids[seat] = amount;
-    if (t.bids.every((b) => b !== null)) {
-      t.phase = "play";
-      t.turn = first(t);
-    } else {
-      t.turn = (seat + 1) % count;
-      while (t.bids[t.turn] !== null) t.turn = (t.turn + 1) % count;
-    }
-    return t;
-  }
-  if (s.phase === "moon") {
-    if (type !== "moon" || ![0, 1].includes(amount ?? -1))
-      throw Error("Choose how to score the moon.");
-    t.penalties = t.penalties.map(
-      (_, i) => amount === 0 ? i === seat ? -26 : 0 : i === seat ? 0 : 26
-    );
-    finish(t);
-    return t;
-  }
-  if (type !== "play" || at === void 0 || !trickLegalCards(s).includes(at))
-    throw Error("Choose a legal card.");
-  t.hands[seat] = t.hands[seat].filter((c) => c !== at);
-  t.trick.push({ seat, card: at });
-  if (s.variant === "spades" && cardSuit(at) === 3 && s.trick.length > 0 && cardSuit(s.trick[0].card) !== 3 || s.variant === "hearts" && (cardSuit(at) === 2 || at === 49))
-    t.broken = true;
-  t.turn = (seat + 1) % count;
-  if (t.trick.length === count) {
-    const lead = cardSuit(t.trick[0].card), strength = (c) => (cardSuit(c) === s.trump ? 100 : cardSuit(c) === lead ? 50 : 0) + cardRank(c);
-    const winner2 = t.trick.reduce(
-      (a, b) => strength(b.card) > strength(a.card) ? b : a
-    ).seat;
-    t.tricks[winner2]++;
-    t.penalties[winner2] += t.trick.reduce((n, c) => n + penalty(c.card), 0);
-    t.lastTrick = t.trick;
-    t.trick = [];
-    t.turn = winner2;
-    if (t.hands.every((h) => !h.length)) {
-      const moon = s.variant === "hearts" ? t.penalties.findIndex((n) => n === 26) : -1;
-      if (moon >= 0) {
-        t.phase = "moon";
-        t.turn = moon;
-      } else finish(t);
-    }
+// lib/multiplayer/dice.ts
+var diceCategories = [
+  "Ones",
+  "Twos",
+  "Threes",
+  "Fours",
+  "Fives",
+  "Sixes",
+  "Three of a kind",
+  "Four of a kind",
+  "Full house",
+  "Small straight",
+  "Large straight",
+  "Five of a kind",
+  "Chance"
+];
+function createDice(count) {
+  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
+  return {
+    dice: [0, 0, 0, 0, 0],
+    held: Array(5).fill(false),
+    rolls: 0,
+    sheets: Array.from({ length: count }, () => Array(13).fill(null)),
+    bonuses: Array(count).fill(0),
+    turn: 0,
+    finished: false,
+    winner: null
+  };
+}
+function diceScore(dice, category, joker = false) {
+  const counts = Array.from(
+    { length: 6 },
+    (_, i) => dice.filter((v) => v === i + 1).length
+  ), sum = dice.reduce((a, b) => a + b, 0);
+  if (category < 6) return counts[category] * (category + 1);
+  switch (category) {
+    case 6:
+      return Math.max(...counts) >= 3 ? sum : 0;
+    case 7:
+      return Math.max(...counts) >= 4 ? sum : 0;
+    case 8:
+      return joker || counts.includes(3) && counts.includes(2) ? 25 : 0;
+    case 9:
+      return joker || [0, 1, 2].some((start) => counts.slice(start, start + 4).every(Boolean)) ? 30 : 0;
+    case 10:
+      return joker || [0, 1].some((start) => counts.slice(start, start + 5).every(Boolean)) ? 40 : 0;
+    case 11:
+      return counts.includes(5) ? 50 : 0;
+    case 12:
+      return sum;
+    default:
+      throw Error("Choose a score category.");
   }
-  return t;
 }
-function trickView(s, seat) {
-  const { stock, selected, ...publicState } = s;
-  return {
-    ...publicState,
-    stockCount: stock.length,
-    selected: selected.map((cards, i) => i === seat ? cards : []),
-    hands: s.hands.map(
-      (h, i) => i === seat && !(s.phase === "blind" && !s.blindAsked[i]) ? h : h.map(() => null)
-    )
+function diceTotal(s, seat) {
+  const sheet = s.sheets[seat], upper = sheet.slice(0, 6).reduce((sum, n) => sum + (n ?? 0), 0);
+  return sheet.reduce((sum, n) => sum + (n ?? 0), 0) + (upper >= 63 ? 35 : 0) + s.bonuses[seat];
+}
+function playDice(s, type, at, entropy2) {
+  if (s.finished) throw Error("This match is finished.");
+  if (type === "roll") {
+    if (s.rolls >= 3) throw Error("Record a score after three rolls.");
+    const random = draws(entropy2, 5);
+    return {
+      ...s,
+      rolls: s.rolls + 1,
+      dice: s.dice.map(
+        (v, i) => s.rolls && s.held[i] ? v : 1 + Math.floor(random[i] * 6)
+      )
+    };
+  }
+  if (at === void 0 || !index(at, type === "hold" ? 5 : 13) || !s.rolls)
+    throw Error("Roll first, then choose a die or score category.");
+  if (type === "hold")
+    return { ...s, held: s.held.map((v, i) => i === at ? !v : v) };
+  if (type !== "score" || s.sheets[s.turn][at] !== null)
+    throw Error("Choose an unused score category.");
+  const sheets = s.sheets.map((row) => [...row]), bonuses = [...s.bonuses];
+  const five = s.dice.every((v) => v === s.dice[0]), upper = s.dice[0] - 1;
+  const joker = five && sheets[s.turn][11] !== null && sheets[s.turn][upper] !== null;
+  if (joker && sheets[s.turn].slice(6).some((n) => n === null) && at < 6)
+    throw Error(
+      "Use the five-of-a-kind joker in an unused lower category first."
+    );
+  sheets[s.turn][at] = diceScore(s.dice, at, joker);
+  if (joker && sheets[s.turn][11] === 50) bonuses[s.turn] += 100;
+  const next3 = {
+    ...s,
+    sheets,
+    bonuses,
+    turn: (s.turn + 1) % s.sheets.length,
+    rolls: 0,
+    held: Array(5).fill(false),
+    dice: [0, 0, 0, 0, 0]
   };
+  next3.finished = sheets.every((row) => row.every((n) => n !== null));
+  if (next3.finished)
+    next3.winner = best(sheets.map((_, i) => diceTotal(next3, i)));
+  return next3;
 }
 
-// lib/multiplayer/cribbage.ts
-var cribbageLabel = (c) => ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"][c % 13] + ["\u2663", "\u2666", "\u2665", "\u2660"][Math.floor(c / 13)];
+// lib/agents/action-help.ts
+var help = {
+  amazons: "move: numeric from/to 0\u201399 and amount for the arrow square. Select an exact legal_wire_actions entry.",
+  "lines-of-action": "move: numeric from/to 0\u201363. Move the count of all stones along the full line; enemy stones block jumping.",
+  "last-greenhouse": "share: publish your current private journal observation. pass: hand controls to partner. choose: at 0\u20133 selects a room setting. All choices are listed, including incorrect answers. Cooperate using both journals.",
+  euchre: "Use visible_state.legalActions. trump: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades; promotion alone optionally sits your partner out. pass declines trump. discard/play: at is a held card ID, not a hand index. IDs are suit*6+rank, ranks 0\u20135 mean 9,10,J,Q,K,A. The left bower belongs to trump for following suit. next deals after a hand. Partners are opposite seats; first team to 10 wins.",
+  cribbage: "Use visible_state.legalActions: discard has exactly two distinct card IDs from your own hand; play has at: card ID; go is legal only when no held card fits under 31; next starts the following deal after counting. Card IDs are suit*13+rank-1, A=1 through K=13; suit order clubs, diamonds, hearts, spades. Crib and opponents' unplayed cards remain hidden.",
+  fanorona: "Use visible_state.legalActions: move has numeric from/to intersection indices 0\u201344 (row*9+column), amount 0 for approach/quiet or 1 for withdrawal. stop ends an optional capture continuation. Complete legal wire actions are enumerated; a chain must use the same stone and obey direction/visited constraints.",
+  categories: `begin: host starts a timed round; promotion:'untimed' disables the timer. submit/stop: text is a string holding a JSON array of six English answers in category order, for example text set to the string '["Apple","Ant",...]' (not a raw array); stop needs a complete sheet. expire reveals a timed-out round. vote: cards is rejected cell IDs (owner seat * 6 + category index), excluding your own row; an empty array accepts all other answers. next: host advances. Answers and ballots lock once submitted. Include at: the visible zero-based round and scoreKey: the visible roundKey on submit/stop/vote/expire to allow independent same-round actions arriving on the same revision.`,
+  cheat: "play: cards is one to four card IDs from your hand, claiming the displayed rank. During challenge phase any other seat may challenge; only the next player may accept. Final-card claims must resolve before a win.",
+  president: "play: cards is one to four equal-rank card IDs. Match pile size and beat its rank; 2 is high. Opening group includes 3 of clubs. pass sits out until the pile clears. Finished seats leave play; order gives final places.",
+  rummy: "stock/upcard: draw first. meld: cards is a set or run of held card IDs. layoff: at is a public meld index, cards is held card IDs to add. discard: at is a held card ID. Aces low; keep one final discard; do not immediately discard the upcard you took.",
+  "connect-four": "place: at is a zero-based column (0\u20136). Convenience: --column 1\u20137.",
+  "tic-tac-toe": "place: at is a zero-based row-major square (0\u20138). legal_actions use one-based row/column instead; pass either form.",
+  chess: "move: from/to are algebraic squares; promotion is q/r/b/n.",
+  "atomic-chess": "move: from/to are algebraic squares; promotion is q/r/b/n. Explosions follow the game rules.",
+  "three-check": "move: from/to are algebraic squares; promotion is q/r/b/n. Check counts are in visible_state.",
+  checkers: "move: from/to are zero-based row-major squares (0\u201363); continue a mandatory capture chain. Men move and capture forward only; kings move both ways. Convenience flags use algebraic squares.",
+  "brazilian-checkers": "move: from/to are zero-based squares (0\u201363); maximum captures apply.",
+  "international-draughts": "move: from/to are zero-based squares (0\u201399). sequence: cards is a complete legal path of square indexes, including the origin.",
+  reversi: "place: at is a zero-based row-major square (0\u201363). Unavailable turns pass automatically.",
+  gomoku: "place: at is a zero-based row-major intersection (0\u2013224). Exactly five wins.",
+  hex: "place: at is a zero-based row-major hexagon. swap: no payload, only the second seat's first turn. Convenience: --row/--column or --swap.",
+  "dots-boxes": 'Send a legal_actions entry ({"type":"edge","edge":N}, one-based) unchanged or use --edge N; the CLI converts it to the wire action place with zero-based at = N-1 (visible_state.edges[N-1]). board_labeled lists each box with its edge numbers. Horizontal edges precede vertical edges in row-major order. Edges and box owners are in visible_state. Convenience: --edge is one-based.',
+  oware: "sow: at is a zero-based pit index, 0\u20135 for seat 0 and 6\u201311 for seat 1. Convenience: --pit is one-based.",
+  go: "place/dead: at is a zero-based row-major intersection (board_labeled shows row start indexes). pass/resume: no payload. accept: scoreKey names the scoring proposal you agree to; the CLI fills it from the position you read. Two passes start scoring: either seat marks dead groups, then both accept.",
+  battleships: "auto/clear/ready: no payload. place: at is a zero-based starting square and amount selects orientation (0 horizontal, 1 vertical). fire: at is a zero-based target square. Inspect your fleet/setup phase; enemy ships remain hidden.",
+  mills: "place/capture: at is a zero-based point index. move: from is the origin and at the destination. Completing a mill requires a subsequent capture action.",
+  dice: `roll: no payload. hold: at is a die index (0\u20134) to toggle its hold after rolling. score: at is a category index: ${diceCategories.map((name, i) => `${i} ${name}`).join(", ")}. Inspect the roll phase and score sheet.`,
+  ludo: "roll: no payload. move: at is the index (0\u20133) of your token. Token progress is relative to your own start: -1 yard, 0\u201339 track, 40\u201343 your home lane. Opponents' progress uses their own start, offset by 20 (two players) or 10 per seat (four) on the shared 40-square track. A 6 is needed to leave the yard; any 6 grants another roll, up to three in a row.",
+  domino: "tile: at is your zero-based hand position (not a pip value) and amount selects the chain end: 0 left, 1 right. draw: draw until you can play, or pass when the stock is empty. next: start the following round. Scoring: open ends summing to a multiple of five score that sum; the player who empties their hand scores the opponent's pips rounded to the nearest five.",
+  football: "place: at is a zero-based destination point. The state records ball, used edges and continuing rebounds.",
+  backgammon: "roll: no payload. move: numeric from/to and amount (die value), one die per action. Points are 0\u201323. Positive point counts are seat 0, negative seat 1. Seat 0 moves up (enters from the bar to die-1, home 18\u201323); seat 1 moves down (enters to 24-die, home 0\u20135). from -1 means the bar; to 24 bears off for both seats. Compulsory dice usage is enforced.",
+  shogi: "move: from is a zero-based square or a hand-piece type for a drop; to is a zero-based square; promotion:'yes' promotes. Inspect your hands and piece owners.",
+  xiangqi: "move: numeric zero-based row-major from/to on the 9\xD710 board. promotion is unused.",
+  poker: "fold/check/call/next: no payload. raise: amount is the desired bet total. Follow phase, pot, current bet, your cards and stack. next is a between-hand host action.",
+  durak: "play: at is your card ID from the visible hand; take/pass: no payload. Follow attack/defence roles and visible trump/table.",
+  makao: "play: cards is 1\u20134 card IDs from your visible hand, all of the same rank. amount chooses an ace suit (0 clubs, 1 diamonds, 2 hearts, 3 spades) or a jack demand (rank 5\u201310 or 13 for king; 0 for no demand); visible_state.suit and demand use the same numbers; promotion:'makao' announces the last card. draw/pass/catch act according to phase. Inspect drawn-card and demand state.",
+  pan: "play: cards is an array of card IDs from the visible hand; take/next: no payload. Follow the table rank and legal group rules.",
+  "gin-rummy": "stock/upcard/pass/next: no payload. discard/knock: at is a card ID from the visible hand. Inspect draw/discard phase and deadwood rules.",
+  "sixty-six": "play: at is a card ID from the visible hand; promotion:'marriage' or 'marriage-claim' declares. exchange/close/claim/next are phase-specific commands.",
+  hearts: "select: at is a card ID from the visible hand for passing (selecting a chosen card again unselects it; visible_state.selected shows your choice), then pass. play: at is a card ID from the visible hand. moon: amount selects a scoring choice. Follow phase, lead suit and legal cards.",
+  spades: "bid: amount is the bid; blind/look for blind nil where offered. play: at is a card ID from the visible hand. Follow partner, phase and lead suit.",
+  "oh-hell": "bid: amount is the bid. play: at is a card ID from the visible hand. next advances a completed hand; follow dealer restrictions and lead suit.",
+  "three-five-eight": "exchange: at is one card ID from your visible hand. discard: cards is exactly four distinct card IDs from your visible hand. play: at is one card ID from your visible hand. contract: amount 0\u20133 chooses a suit, 4 no trumps, 5 misere. next advances the hand.",
+  bridge: "bid: amount 1\u201335 encodes level floor((amount-1)/5)+1 and strain (amount-1)%5; pass/double/redouble have no payload. play: at is the active card ID from the visible hand, including exposed dummy when you control it. Follow auction, strain and lead-suit rules.",
+  "polish-hearts": "trump: amount is a suit index; pass: no payload, only when no layout card fits; play: at is a card ID from the visible hand. Follow the current penalty/trump/layout phase.",
+  thousand: "bid/declare: amount is points. kitty: at selects a kitty. exchange: cards is card IDs from the visible hand. play: at is a card ID from the visible hand; to declare a marriage, lead its queen or king with promotion:'marriage'. pass/bomb/redeal/next depend on phase. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades; ranks 9 through ace). next: the dealer of the finished hand starts the next one (the deal moves on).",
+  binokel: "bid: amount is points; trump: amount is a suit; play: at is a card ID from the visible hand. pass/next have no payload. Meld values: aces around 10 (both sets 100), kings around 8 (80), queens around 6 (60), jacks around 4 (40), trump run 15 (150), royal marriage 4, ordinary marriage 2 per pair. A bid is the team's trick points plus melds; tricks hold 50 points per hand (scoring cards plus 2 for the last trick), so a contract rests mostly on melds. The declaring team needs 20 meld points.",
+  skat: "bid: amount is an auction value; hold/pass/hand/pickup act in auction/pickup phases (after a hold the bidder must bid higher or pass). discard: cards is exactly two card IDs from your visible hand. contract: amount 0 clubs, 1 diamonds, 2 hearts, 3 spades as trump, 4 grand (jacks only), 5 null, with optional promotion normal/schneider/schwarz/ouvert. play: at is a card ID from the visible hand. Jacks rank clubs, spades, hearts, diamonds. Card IDs are suit*13+rank-2 (suits clubs, diamonds, hearts, spades). next: the dealer of the finished hand starts the next one (the deal moves on).",
+  baska: "announce: no payload in the honor phase. contract: amount is one of 1,3,4,5,6 and must exceed the current contract. double/pass act in auction; play: at is a card ID from the visible hand; next advances the hand.",
+  canasta: "stock/next: no payload. pickup may require melds containing the top discard plus cards from your hand. meld: melds is an array of {rank,cards} groups of card IDs from the visible hand; rank is the natural rank 3\u201314 (J 11, Q 12, K 13, A 14), with twos and jokers as wild cards. cards_labeled names each card. discard: at is a card ID from the visible hand. Follow opening meld and canasta requirements. Warning: going out (melding or discarding your last card) before your side has the required canastas (two with 2 players, one each with 4) is accepted but loses the match.",
+  "letter-tiles": "place: placements is an array of {at,rack,letter?}; at is a board index and rack a rack index, letter assigns a blank. exchange: cards is rack indexes. accept/challenge/pass/next depend on phase.",
+  "draw-guess": "choose: at selects one of your offered prompts. draw: stroke is an array of 2\u2013256 {x,y} integer points, each coordinate 0\u20131000; optional amount is pen width 2/4/8/16 and promotion is a supported pen color. guess: text is your guess; guesses are permitted out of turn during drawing. clear/expire/next depend on phase. Hidden prompts stay hidden from guessers.",
+  "property-trading": "roll/end/buy/auction/pay/bankrupt/pass/reject have phase-specific effects. bid: amount is the bid. mortgage/redeem/build/sell: at selects a property. tax: amount is 0 or 1. release: amount 0 pays fifty, 1 uses a release card. offer: tradeOffer contains seat,give,take,giveCash,takeCash; accept confirms the current trade."
+};
+function actionHelp(game) {
+  return { format: `game play --room CODE --revision R --action '{"type":"...",...}'`, indexing: "Board and hand-position indexes are zero-based. Card IDs are the actual values in visible_state, not offsets into a hand array. Convenience --row/--column/--edge/--pit flags are one-based. Inspect the exact player-visible state; do not guess hidden cards or board indexes.", game: help[game], validation: "action_types lists permitted command families, not currently legal moves. The server enforces phases, turns, ownership and legality. After a rejected or uncertain action read status again; never retry blindly." };
+}
 
 // lib/multiplayer/euchre.ts
 var euchreSuit = (card2) => Math.floor(card2 / 6);
@@ -4755,7 +5179,7 @@ function redFromHand(t, seat, replace) {
     }
   return true;
 }
-function deal2(s, entropy2) {
+function deal3(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 108 }, (_, i) => i),
     entropy2
@@ -4778,7 +5202,7 @@ function deal2(s, entropy2) {
 }
 function createCanasta(count, entropy2) {
   if (count !== 2 && count !== 4) throw Error("Choose two or four players.");
-  return deal2(
+  return deal3(
     {
       hands: Array.from({ length: count }, () => []),
       stock: [],
@@ -4857,7 +5281,7 @@ function playCanasta(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (t.dealer + 1) % s.hands.length;
-    return deal2(t, entropy2);
+    return deal3(t, entropy2);
   }
   if (a.type === "stock" && s.phase === "draw") {
     t.openingTurn = !s.opened[i];
@@ -5001,7 +5425,7 @@ function binokelMeld(hand2, trump) {
   add([16, 5], [0, 4, 30, 60, 90], "binokel");
   return { score, labels: labels2, shown: [...shown] };
 }
-function deal3(s, entropy2) {
+function deal4(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 80 }, (_, i) => i),
     entropy2
@@ -5024,7 +5448,7 @@ function deal3(s, entropy2) {
   return t;
 }
 function createBinokel(entropy2) {
-  return deal3(
+  return deal4(
     {
       hands: [[], [], [], []],
       turn: 0,
@@ -5072,7 +5496,7 @@ function playBinokel(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (t.dealer + 1) % 4;
-    return deal3(t, entropy2);
+    return deal4(t, entropy2);
   }
   if (s.phase === "auction") {
     if (a.type === "bid" && a.amount !== void 0 && Number.isInteger(a.amount) && a.amount > s.bid && (a.amount < 60 || a.amount % 5 === 0) && a.amount <= 1e3) {
@@ -5246,7 +5670,7 @@ function nextSeat(s, from, eligible) {
   return -1;
 }
 var canAct = (p) => !p.folded && !p.out && p.stack > 0;
-function deal4(s, n) {
+function deal5(s, n) {
   s.deck.pop();
   for (let i = 0; i < n; i++) s.community.push(s.deck.pop());
 }
@@ -5311,13 +5735,13 @@ function advance(s) {
   }
   if (s.phase === "river") return award(s);
   if (s.phase === "preflop") {
-    deal4(s, 3);
+    deal5(s, 3);
     s.phase = "flop";
   } else if (s.phase === "flop") {
-    deal4(s, 1);
+    deal5(s, 1);
     s.phase = "turn";
   } else {
-    deal4(s, 1);
+    deal5(s, 1);
     s.phase = "river";
   }
   s.bet = 0;
@@ -5538,6 +5962,7 @@ var labels = {
 var singleCard = /^(upcard|starter|top|trumpCard|card|attack|defen[cs]e|turned)$/;
 var suits = ["\u2663 clubs", "\u2666 diamonds", "\u2665 hearts", "\u2660 spades"];
 var cardField = /^(hands?|hole|trick|lastTrick|tricks?Won|pile|table|attack|defen[cs]e|discards?|kitty|kitties|shownKitty|skat|crib|starter|upcard|top|community|board|melds?|layout|red|revealed|played|dummy|selected|cards?|exchange|stock|widow|talon|turned|trumpCard|last)$/;
+var hasCardLabels = (game) => game in labels;
 function cardsLabeled(game, state) {
   const label = labels[game];
   if (!label || !state || typeof state !== "object") return null;
@@ -7881,125 +8306,27 @@ function playBackgammon(s, type, from, to, die, entropy2) {
       dice: [],
       turn: turn === 0 ? 1 : 0,
       result: "All moves are blocked. Turn passes."
-    };
-  }
-  const move2 = backgammonMoves(s).find(
-    (m) => m.from === from && m.to === to && m.die === die
-  );
-  if (type !== "move" || !move2)
-    throw Error(
-      "Use the maximum number of dice; if only one can be used, use the higher die."
-    );
-  const next3 = step(s, move2);
-  if (next3.off[s.turn] === 15) {
-    const opponent = 1 - s.turn, backgammon = next3.bar[opponent] > 0 || next3.points.some(
-      (n, i) => (s.turn === 0 ? i >= 18 : i < 6) && n * (s.turn === 0 ? -1 : 1) > 0
-    );
-    next3.winner = s.turn;
-    next3.result = next3.off[opponent] ? "Single game." : backgammon ? "Backgammon \xB7 3 points." : "Gammon \xB7 2 points.";
-  } else if (!backgammonMoves(next3).length) {
-    next3.dice = [];
-    next3.turn = s.turn === 0 ? 1 : 0;
-  }
-  return next3;
-}
-
-// lib/multiplayer/mills.ts
-var millLines = [
-  [0, 1, 2],
-  [2, 3, 4],
-  [4, 5, 6],
-  [6, 7, 0],
-  [8, 9, 10],
-  [10, 11, 12],
-  [12, 13, 14],
-  [14, 15, 8],
-  [16, 17, 18],
-  [18, 19, 20],
-  [20, 21, 22],
-  [22, 23, 16],
-  [1, 9, 17],
-  [3, 11, 19],
-  [5, 13, 21],
-  [7, 15, 23]
-];
-var millEdges = millLines.flatMap(([a, b, c]) => [
-  [a, b],
-  [b, c]
-]);
-function createMills() {
-  return {
-    board: Array(24).fill(0),
-    reserves: [9, 9],
-    turn: 0,
-    captures: 0,
-    winner: null,
-    draw: false,
-    history: []
-  };
-}
-var linesAt = (board, at) => millLines.filter(
-  (line) => line.includes(at) && line.every((i) => board[i] === board[at])
-);
-function millCaptures(s) {
-  const opponents = s.board.flatMap((p, i) => p === 2 - s.turn ? [i] : []), loose = opponents.filter((at) => !linesAt(s.board, at).length);
-  return loose.length ? loose : opponents;
-}
-function millMoves(s) {
-  if (s.winner !== null || s.draw || s.captures) return [];
-  const empty = s.board.flatMap((p, i) => !p ? [i] : []);
-  if (s.reserves[s.turn]) return empty.map((to) => ({ from: null, to }));
-  const own = s.board.flatMap((p, i) => p === s.turn + 1 ? [i] : []);
-  return own.flatMap(
-    (from) => empty.filter(
-      (to) => own.length === 3 || millEdges.some(
-        ([a, b]) => a === from && b === to || b === from && a === to
-      )
-    ).map((to) => ({ from, to }))
-  );
-}
-function finishTurn(s) {
-  const turn = s.turn === 0 ? 1 : 0, key2 = s.board.join(",") + ":" + turn + ":" + s.reserves.join(",");
-  const next3 = {
-    ...s,
-    turn,
-    captures: 0,
-    history: [...s.history, key2]
-  };
-  const count = next3.board.filter((p) => p === turn + 1).length;
-  if (!next3.reserves[turn] && (count < 3 || !millMoves(next3).length))
-    next3.winner = s.turn;
-  else next3.draw = next3.history.filter((k) => k === key2).length >= 3;
-  return next3;
-}
-function playMills(s, type, to, from) {
-  if (!index(to, 24) || s.winner !== null || s.draw)
-    throw Error("Choose a legal point.");
-  const board = [...s.board], reserves = [...s.reserves];
-  if (type === "capture") {
-    if (!s.captures || !millCaptures(s).includes(to))
-      throw Error(
-        "Capture a piece outside a mill, unless all pieces are in mills."
-      );
-    board[to] = 0;
-    const next4 = { ...s, board, captures: s.captures - 1 };
-    return next4.captures && millCaptures(next4).length ? next4 : finishTurn(next4);
+    };
   }
-  if (!["place", "move"].includes(type) || !millMoves(s).some(
-    (m) => m.to === to && m.from === (type === "place" ? null : from)
-  ))
+  const move2 = backgammonMoves(s).find(
+    (m) => m.from === from && m.to === to && m.die === die
+  );
+  if (type !== "move" || !move2)
     throw Error(
-      "Place from your reserve or move to a connected point. With three pieces you may fly."
+      "Use the maximum number of dice; if only one can be used, use the higher die."
     );
-  if (type === "place") reserves[s.turn]--;
-  else board[from] = 0;
-  board[to] = s.turn + 1;
-  const captures = Math.min(
-    linesAt(board, to).length,
-    board.filter((p) => p === 2 - s.turn).length
-  );
-  const next3 = { ...s, board, reserves, captures };
-  return captures ? next3 : finishTurn(next3);
+  const next3 = step(s, move2);
+  if (next3.off[s.turn] === 15) {
+    const opponent = 1 - s.turn, backgammon = next3.bar[opponent] > 0 || next3.points.some(
+      (n, i) => (s.turn === 0 ? i >= 18 : i < 6) && n * (s.turn === 0 ? -1 : 1) > 0
+    );
+    next3.winner = s.turn;
+    next3.result = next3.off[opponent] ? "Single game." : backgammon ? "Backgammon \xB7 3 points." : "Gammon \xB7 2 points.";
+  } else if (!backgammonMoves(next3).length) {
+    next3.dice = [];
+    next3.turn = s.turn === 0 ? 1 : 0;
+  }
+  return next3;
 }
 
 // lib/multiplayer/football.ts
@@ -8270,13 +8597,13 @@ function goAction(s, seat, action, at) {
   }
   const accepted = [.../* @__PURE__ */ new Set([...s.accepted, seat])];
   if (accepted.length < 2) return { ...s, accepted };
-  const scores = scoreGo(s);
+  const scores2 = scoreGo(s);
   return {
     ...s,
     accepted,
-    scores,
+    scores: scores2,
     phase: "finished",
-    winner: scores[0] > scores[1] ? 0 : 1
+    winner: scores2[0] > scores2[1] ? 0 : 1
   };
 }
 function goProposalKey(s) {
@@ -8333,7 +8660,7 @@ var adapter3 = defineMatchAdapter({
     return {
       finished: state.winner !== null || state.draw,
       winner: state.winner,
-      label: state.draw ? "Repetition or insufficient material" : state.winner !== null ? `${state.check ? "Checkmate" : "No legal move"} \xB7 Player ${state.winner + 1} wins.` : state.check ? "Check" : ""
+      label: state.draw ? "Draw \xB7 repetition, insufficient material or the move limit" : state.winner !== null ? `${state.check ? "Checkmate" : "No legal move"} \xB7 Player ${state.winner + 1} wins.` : state.check ? "Check" : ""
     };
   },
   apply(state, _seat, action, _entropy, _now) {
@@ -8357,7 +8684,7 @@ var adapter4 = defineMatchAdapter({
     return {
       finished: state.winner !== null || state.draw,
       winner: state.winner,
-      label: state.draw ? "Repetition or insufficient material" : state.winner !== null ? `${state.check ? "Checkmate" : "No legal move"} \xB7 Player ${state.winner + 1} wins.` : state.check ? "Check" : ""
+      label: state.draw ? "Draw \xB7 repetition, insufficient material or the move limit" : state.winner !== null ? `${state.check ? "Checkmate" : "No legal move"} \xB7 Player ${state.winner + 1} wins.` : state.check ? "Check" : ""
     };
   },
   apply(state, _seat, action, _entropy, _now) {
@@ -8444,7 +8771,7 @@ var adapter8 = defineMatchAdapter({
     return {
       finished: state.winner !== null || state.draw,
       winner: state.winner,
-      label: state.draw ? "Draw" : state.winner !== null ? `Player ${state.winner + 1} wins \xB7 the opponent is down to two pieces or blocked.` : ""
+      label: state.draw ? "Draw" : state.winner !== null ? `Player ${state.winner + 1} wins \xB7 ${state.board.filter((p) => p === 2 - state.winner).length < 3 ? "the opponent is down to two pieces" : "the opponent has no legal move"}.` : ""
     };
   },
   apply(state, _seat, action, _entropy, _now) {
@@ -8492,7 +8819,7 @@ var adapter10 = defineMatchAdapter({
     return {
       finished: state.winner !== null,
       winner: state.winner,
-      label: state.last
+      label: state.winner !== null ? `Player ${state.winner + 1} brings all four tokens home and wins.` : state.last
     };
   },
   apply(state, _seat, action, entropy2, _now) {
@@ -8631,9 +8958,9 @@ function loserResult(count, loser) {
   validSeat(count, loser);
   return { sides: Array.from({ length: count }, (_, seat) => ({ seats: [seat], place: seat === loser ? 1 : 0 })) };
 }
-function scoreResult(scores, winner2, lowerWins = false) {
-  validSeat(scores.length, winner2);
-  const values = scores.map((n) => lowerWins ? -n : n);
+function scoreResult(scores2, winner2, lowerWins = false) {
+  validSeat(scores2.length, winner2);
+  const values = scores2.map((n) => lowerWins ? -n : n);
   return { sides: values.map((value, seat) => ({ seats: [seat], place: seat === winner2 ? 0 : Number(winner2 !== null) + values.filter((n, i) => i !== winner2 && n > value).length })) };
 }
 function partnershipResult(count, winner2) {
@@ -8650,7 +8977,7 @@ function next(s, seat) {
   const i = s.players.indexOf(seat);
   return s.players[(i + 1) % s.players.length];
 }
-function deal5(s, entropy2) {
+function deal6(s, entropy2) {
   const t = structuredClone(s), count = s.hands.length, deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter((c) => cardRank(c) >= 9),
     entropy2
@@ -8682,7 +9009,7 @@ function deal5(s, entropy2) {
 }
 function createThousand(count, entropy2) {
   if (!index(count - 2, 3)) throw Error("Choose two to four players.");
-  return deal5(
+  return deal6(
     {
       hands: Array.from({ length: count }, () => []),
       kitties: [],
@@ -8734,10 +9061,10 @@ function playThousand(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (s.dealer + 1) % s.hands.length;
-    return deal5(t, entropy2);
+    return deal6(t, entropy2);
   }
   if (a.type === "redeal" && s.phase === "auction" && s.hands[seat].filter((c) => cardRank(c) === 9).length === 4)
-    return deal5(t, entropy2);
+    return deal6(t, entropy2);
   if (s.phase === "auction") {
     if (a.type === "bid" && a.amount !== void 0 && Number.isInteger(a.amount) && a.amount % 10 === 0 && a.amount > s.bid && a.amount <= thousandMaxBid(s.hands[seat])) {
       t.bid = a.amount;
@@ -8907,7 +9234,7 @@ var skatBids = [
     )
   ])
 ].filter((n) => n <= 264).sort((a, b) => a - b);
-function deal6(s, entropy2) {
+function deal7(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter((c) => cardRank(c) >= 7),
     entropy2
@@ -8941,7 +9268,7 @@ function deal6(s, entropy2) {
   return t;
 }
 function createSkat(entropy2) {
-  return deal6(
+  return deal7(
     {
       hands: [[], [], []],
       skat: [],
@@ -9042,7 +9369,7 @@ function playSkat(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (s.dealer + 1) % 3;
-    return deal6(t, entropy2);
+    return deal7(t, entropy2);
   }
   if (s.phase === "auction") {
     if (s.offer === null) {
@@ -9203,7 +9530,7 @@ function sides(t) {
     t.old = t.hands.map((_, i) => i === t.declarer);
   else t.old = t.hands.map((h) => queens.some((c) => h.includes(c)));
 }
-function deal7(s, entropy2) {
+function deal8(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter(
       (c) => [10, 11, 12, 14].includes(cardRank(c))
@@ -9244,7 +9571,7 @@ function deal7(s, entropy2) {
   return t;
 }
 function createBaska(entropy2) {
-  return deal7(
+  return deal8(
     {
       hands: [[], [], [], []],
       turn: 0,
@@ -9313,7 +9640,7 @@ function playBaska(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (t.dealer + 1) % 4;
-    return deal7(t, entropy2);
+    return deal8(t, entropy2);
   }
   if (a.type === "announce" && s.phase === "honor") {
     finish5(t, true);
@@ -9433,7 +9760,7 @@ var adapter17 = defineMatchAdapter({
 
 // lib/multiplayer/bridge.ts
 var vulnerability = [0, 1, 2, 3, 1, 2, 3, 0, 2, 3, 0, 1, 3, 0, 1, 2];
-function deal8(s, entropy2) {
+function deal9(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i),
     entropy2
@@ -9461,7 +9788,7 @@ function deal8(s, entropy2) {
   return t;
 }
 function createBridge(entropy2) {
-  return deal8(
+  return deal9(
     {
       hands: [[], [], [], []],
       turn: 0,
@@ -9514,7 +9841,7 @@ function playBridge(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.board++;
     t.dealer = (t.dealer + 1) % 4;
-    return deal8(t, entropy2);
+    return deal9(t, entropy2);
   }
   if (s.phase === "auction") {
     if (a.type === "bid" && index((a.amount ?? 0) - 1, 35)) {
@@ -9620,7 +9947,7 @@ var adapter18 = defineMatchAdapter({
 });
 
 // lib/multiplayer/polish-hearts.ts
-function deal9(s, entropy2) {
+function deal10(s, entropy2) {
   const t = structuredClone(s), count = s.hands.length, deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter(
       (c) => count !== 3 || c !== 0
@@ -9647,7 +9974,7 @@ function deal9(s, entropy2) {
 }
 function createPolish(count, entropy2) {
   if (count !== 3 && count !== 4) throw Error("Choose three or four players.");
-  return deal9(
+  return deal10(
     {
       hands: Array.from({ length: count }, () => []),
       rest: [],
@@ -9711,7 +10038,7 @@ function playPolish(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (t.dealer + 1) % count;
-    return deal9(t, entropy2);
+    return deal10(t, entropy2);
   }
   if (a.type === "trump" && s.phase === "trump" && index(a.amount ?? -1, 4)) {
     t.trump = a.amount;
@@ -10184,7 +10511,7 @@ var adapter21 = defineMatchAdapter({
 });
 
 // lib/multiplayer/three-five-eight.ts
-function deal10(s, entropy2) {
+function deal11(s, entropy2) {
   const t = structuredClone(s), deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i),
     entropy2
@@ -10221,7 +10548,7 @@ function deal10(s, entropy2) {
   return t;
 }
 function createThree(entropy2) {
-  return deal10(
+  return deal11(
     {
       hands: [[], [], []],
       kitty: [],
@@ -10260,7 +10587,7 @@ function playThree(s, a, entropy2) {
   if (a.type === "next" && s.phase === "round") {
     t.round++;
     t.dealer = (s.dealer + 1) % 3;
-    return deal10(t, entropy2);
+    return deal11(t, entropy2);
   }
   if (s.phase === "exchange" && a.type === "exchange" && a.at !== void 0 && s.hands[s.turn].includes(a.at)) {
     const q = t.exchange[0], suit = cardSuit(a.at), other = t.hands[q.to].filter((c) => cardSuit(c) === suit).sort((a2, b) => cardRank(b) - cardRank(a2)), returned = other[0];
@@ -10652,6 +10979,7 @@ function settle(s, entropy2) {
     s.bills.shift();
   }
   if (["buy", "tax", "trade", "auction"].includes(s.phase)) return;
+  if (s.players[s.active].bankrupt) s.pendingMove = null;
   if (s.pendingMove !== null) {
     const distance = s.pendingMove;
     s.pendingMove = null;
@@ -11040,297 +11368,114 @@ var adapter26 = defineMatchAdapter({
 
 // lib/multiplayer/pan.ts
 var nineHearts = 33;
-function deal11(count, entropy2, letters, round) {
+function deal12(count, entropy2, letters, round) {
   const cards = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter((c) => cardRank(c) >= 9),
     entropy2
-  ), hands = Array.from(
-    { length: count },
-    (_, i) => cards.slice(i * 24 / count, (i + 1) * 24 / count).sort((a, b) => a - b)
-  );
-  return {
-    hands,
-    pile: [],
-    turn: hands.findIndex((h) => h.includes(nineHearts)),
-    letters,
-    phase: "play",
-    winner: null,
-    loser: null,
-    round,
-    result: ""
-  };
-}
-function createPan(count, entropy2) {
-  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
-  return deal11(count, entropy2, Array(count).fill(0), 0);
-}
-function panLegal(s, cards) {
-  const hand2 = s.hands[s.turn];
-  if (s.phase !== "play" || !cards.length || new Set(cards).size !== cards.length || cards.some((c) => !hand2.includes(c)))
-    return false;
-  const rank2 = cardRank(cards[0]);
-  if (cards.some((c) => cardRank(c) !== rank2)) return false;
-  if (!s.pile.length)
-    return cards.includes(nineHearts) && (cards.length === 1 || cards.length === 4);
-  if (![1, 4].includes(cards.length) && !(cards.length === 3 && rank2 === 9 && s.pile.length === 1))
-    return false;
-  return rank2 >= cardRank(s.pile.at(-1));
-}
-function playPan(s, type, cards, entropy2) {
-  if (type === "next" && s.phase === "round")
-    return deal11(s.hands.length, entropy2, s.letters, s.round + 1);
-  if (s.phase !== "play") throw Error("This round is finished.");
-  const t = structuredClone(s), seat = s.turn;
-  if (type === "play" && panLegal(s, cards)) {
-    const ordered = [...cards].sort(
-      (a, b) => a === nineHearts ? -1 : b === nineHearts ? 1 : a - b
-    );
-    t.pile.push(...ordered);
-    t.hands[seat] = t.hands[seat].filter((c) => !cards.includes(c));
-  } else if (type === "take" && s.pile.length > 1) {
-    t.hands[seat].push(...t.pile.splice(Math.max(1, t.pile.length - 3)));
-    t.hands[seat].sort((a, b) => a - b);
-  } else
-    throw Error(
-      "Play one card, four of a rank, or take up to three from the pile."
-    );
-  const active = t.hands.flatMap((h, i) => h.length ? [i] : []);
-  if (active.length <= 1) {
-    const last = active[0];
-    if (last !== void 0 && panLegal({ ...t, turn: last }, t.hands[last]) && t.hands[last].every((c) => cardRank(c) === 14)) {
-      t.turn = last;
-      return t;
-    }
-    if (last !== void 0) {
-      t.letters[last]++;
-      t.loser = last;
-      t.result = `Player ${last + 1} receives ${"PAN".slice(0, t.letters[last])}.`;
-    } else t.result = "Round drawn: everyone shed their cards.";
-    t.phase = last !== void 0 && t.letters[last] >= 3 ? "finished" : "round";
-    t.winner = t.phase === "finished" && t.hands.length === 2 ? 1 - last : null;
-    t.turn = last ?? seat;
-    return t;
-  }
-  do {
-    t.turn = (t.turn + 1) % t.hands.length;
-  } while (!t.hands[t.turn].length);
-  return t;
-}
-function panView(s, seat) {
-  return {
-    ...s,
-    hands: s.hands.map(
-      (h, i) => i === seat || s.phase !== "play" ? h : h.map(() => null)
-    )
-  };
-}
-
-// lib/multiplayer/adapters/pan.ts
-var adapter27 = defineMatchAdapter({
-  ranking: (state, count) => loserResult(count, state.loser),
-  actions: ["next", "play", "take"],
-  create(count, entropy2, _goSize) {
-    return createPan(count, entropy2);
-  },
-  turn: (state) => state.turn,
-  outcome(state) {
-    return {
-      finished: state.phase === "finished",
-      winner: state.winner,
-      label: state.result
-    };
-  },
-  apply(state, _seat, action, entropy2, _now) {
-    return playPan(state, action.type, action.cards ?? [], entropy2);
-  },
-  view(state, seat) {
-    return panView(state, seat);
-  }
-});
-
-// lib/multiplayer/gin-rummy.ts
-var ginRank = (c) => cardRank(c) === 14 ? 1 : cardRank(c);
-var ginValue = (c) => Math.min(10, ginRank(c));
-function ginMelds(hand2) {
-  const melds = [];
-  for (let rank2 = 1; rank2 <= 13; rank2++) {
-    const cards = hand2.filter((c) => ginRank(c) === rank2);
-    if (cards.length >= 3) {
-      if (cards.length === 4) {
-        melds.push(cards);
-        for (let i = 0; i < 4; i++) melds.push(cards.filter((_, j) => j !== i));
-      } else melds.push(cards);
-    }
-  }
-  for (let suit = 0; suit < 4; suit++) {
-    const cards = hand2.filter((c) => cardSuit(c) === suit).sort((a, b) => ginRank(a) - ginRank(b));
-    for (let start = 0; start < cards.length; start++)
-      for (let end = start + 2; end < cards.length; end++) {
-        const slice = cards.slice(start, end + 1);
-        if (slice.every(
-          (c, i) => i === 0 || ginRank(c) === ginRank(slice[i - 1]) + 1
-        ))
-          melds.push(slice);
-        else break;
-      }
-  }
-  return melds;
-}
-function partitions(hand2) {
-  const melds = ginMelds(hand2), out2 = [];
-  function visit(start, used, chosen) {
-    const deadwood2 = hand2.filter((c) => !used.has(c));
-    out2.push({
-      melds: chosen,
-      deadwood: deadwood2,
-      value: deadwood2.reduce((n, c) => n + ginValue(c), 0)
-    });
-    for (let i = start; i < melds.length; i++)
-      if (melds[i].every((c) => !used.has(c)))
-        visit(i + 1, /* @__PURE__ */ new Set([...used, ...melds[i]]), [...chosen, melds[i]]);
-  }
-  visit(0, /* @__PURE__ */ new Set(), []);
-  return out2;
-}
-function ginLayout(hand2) {
-  return partitions(hand2).reduce((a, b) => b.value < a.value ? b : a);
-}
-function ginLayoffValue(hand2, onto) {
-  const cache = /* @__PURE__ */ new Map();
-  function attach(cards, melds) {
-    const key2 = cards.join(",") + "|" + melds.map((m) => m.join(",")).join(";"), cached = cache.get(key2);
-    if (cached !== void 0) return cached;
-    let best2 = cards.reduce((n, c) => n + ginValue(c), 0);
-    cards.forEach(
-      (c, i) => melds.forEach((m, j) => {
-        const set = m.every((x) => ginRank(x) === ginRank(m[0])), ranks = m.map(ginRank), fits = set ? m.length === 3 && ginRank(c) === ranks[0] : cardSuit(c) === cardSuit(m[0]) && (ginRank(c) === Math.min(...ranks) - 1 || ginRank(c) === Math.max(...ranks) + 1);
-        if (fits) {
-          const next3 = melds.map(
-            (m2, k) => k === j ? [...m2, c].sort((a, b) => ginRank(a) - ginRank(b)) : m2
-          );
-          best2 = Math.min(
-            best2,
-            attach(
-              cards.filter((_, k) => k !== i),
-              next3
-            )
-          );
-        }
-      })
-    );
-    cache.set(key2, best2);
-    return best2;
-  }
-  return Math.min(...partitions(hand2).map((p) => attach(p.deadwood, onto)));
-}
-function deal12(dealer, scores, wins, round, entropy2) {
-  const deck = shuffled(
-    Array.from({ length: 52 }, (_, i) => i),
-    entropy2
-  );
-  return {
-    hands: [
-      deck.slice(0, 10).sort((a, b) => a - b),
-      deck.slice(10, 20).sort((a, b) => a - b)
-    ],
-    stock: deck.slice(21),
-    discard: [deck[20]],
-    turn: 1 - dealer,
-    dealer,
-    phase: "offer",
-    offers: 0,
-    drawnDiscard: null,
-    scores,
-    wins,
+  ), hands = Array.from(
+    { length: count },
+    (_, i) => cards.slice(i * 24 / count, (i + 1) * 24 / count).sort((a, b) => a - b)
+  );
+  return {
+    hands,
+    pile: [],
+    turn: hands.findIndex((h) => h.includes(nineHearts)),
+    letters,
+    phase: "play",
     winner: null,
+    loser: null,
     round,
-    result: "",
-    revealed: [],
-    margin: null
+    result: ""
   };
 }
-function createGin(entropy2) {
-  return deal12(Math.floor(draws(entropy2, 1)[0] * 2), [0, 0], [0, 0], 0, entropy2);
+function createPan(count, entropy2) {
+  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
+  return deal12(count, entropy2, Array(count).fill(0), 0);
 }
-function playGin(s, type, at, entropy2) {
+function panLegal(s, cards) {
+  const hand2 = s.hands[s.turn];
+  if (s.phase !== "play" || !cards.length || new Set(cards).size !== cards.length || cards.some((c) => !hand2.includes(c)))
+    return false;
+  const rank2 = cardRank(cards[0]);
+  if (cards.some((c) => cardRank(c) !== rank2)) return false;
+  if (!s.pile.length)
+    return cards.includes(nineHearts) && (cards.length === 1 || cards.length === 4);
+  if (![1, 4].includes(cards.length) && !(cards.length === 3 && rank2 === 9 && s.pile.length === 1))
+    return false;
+  return rank2 >= cardRank(s.pile.at(-1));
+}
+function playPan(s, type, cards, entropy2) {
   if (type === "next" && s.phase === "round")
-    return deal12(
-      s.result.startsWith("Stock") ? s.dealer : 1 - s.dealer,
-      s.scores,
-      s.wins,
-      s.round + 1,
-      entropy2
-    );
-  if (["finished", "round"].includes(s.phase))
-    throw Error("This round is finished.");
+    return deal12(s.hands.length, entropy2, s.letters, s.round + 1);
+  if (s.phase !== "play") throw Error("This round is finished.");
   const t = structuredClone(s), seat = s.turn;
-  if (type === "pass" && s.phase === "offer") {
-    t.offers++;
-    if (t.offers === 2) {
-      t.phase = "draw";
-      t.turn = 1 - s.dealer;
-    } else t.turn = 1 - seat;
-    return t;
-  }
-  if (["draw", "offer"].includes(s.phase) && ["stock", "upcard"].includes(type)) {
-    if (s.phase === "offer" && type === "stock")
-      throw Error("Take the upcard or pass the opening offer.");
-    if (s.phase === "draw" && s.offers === 2 && s.round === t.round && type === "upcard")
-      throw Error("Both players passed: draw from the stock.");
-    if (s.stock.length <= 2) {
-      t.phase = "round";
-      t.result = "Stock exhausted: round cancelled, same dealer.";
-      t.turn = s.dealer;
-      return t;
-    }
-    const card2 = type === "upcard" ? t.discard.pop() : t.stock.shift();
-    t.drawnDiscard = type === "upcard" ? card2 : null;
-    t.hands[seat].push(card2);
+  if (type === "play" && panLegal(s, cards)) {
+    const ordered = [...cards].sort(
+      (a, b) => a === nineHearts ? -1 : b === nineHearts ? 1 : a - b
+    );
+    t.pile.push(...ordered);
+    t.hands[seat] = t.hands[seat].filter((c) => !cards.includes(c));
+  } else if (type === "take" && s.pile.length > 1) {
+    t.hands[seat].push(...t.pile.splice(Math.max(1, t.pile.length - 3)));
     t.hands[seat].sort((a, b) => a - b);
-    t.phase = "discard";
-    t.offers = 0;
-    return t;
-  }
-  if (s.phase === "discard" && ["discard", "knock"].includes(type) && at !== void 0 && s.hands[seat].includes(at) && at !== s.drawnDiscard) {
-    t.hands[seat] = t.hands[seat].filter((c) => c !== at);
-    t.discard.push(at);
-    t.drawnDiscard = null;
-    if (type === "knock") {
-      const layout = ginLayout(t.hands[seat]);
-      if (layout.value > 10)
-        throw Error("Knock only with ten or fewer deadwood points.");
-      const other = 1 - seat, opp = layout.value === 0 ? ginLayout(t.hands[other]).value : ginLayoffValue(t.hands[other], layout.melds), winner2 = layout.value === 0 || layout.value < opp ? seat : other;
-      const points = layout.value === 0 ? opp + 25 : winner2 === seat ? opp - layout.value : layout.value - opp + 25;
-      t.scores[winner2] += points;
-      t.wins[winner2]++;
-      t.result = `${layout.value === 0 ? "Gin" : winner2 === seat ? "Knock" : "Undercut"}: Player ${winner2 + 1} scores ${points}. Deadwood ${layout.value} vs ${opp}.`;
-      t.revealed = t.hands.map((h) => ginLayout(h).melds);
-      t.phase = t.scores[winner2] >= 100 ? "finished" : "round";
-      t.turn = winner2;
-      if (t.phase === "finished") {
-        t.winner = winner2;
-        t.margin = t.scores[winner2] + 100 + (t.scores[other] === 0 ? 100 : 0) + 25 * t.wins[winner2] - t.scores[other] - 25 * t.wins[other];
-        t.result += ` Final margin including game and hand bonuses: ${t.margin}.`;
-      }
-    } else {
-      t.phase = "draw";
-      t.turn = 1 - seat;
+  } else
+    throw Error(
+      "Play one card, four of a rank, or take up to three from the pile."
+    );
+  const active = t.hands.flatMap((h, i) => h.length ? [i] : []);
+  if (active.length <= 1) {
+    const last = active[0];
+    if (last !== void 0 && panLegal({ ...t, turn: last }, t.hands[last]) && t.hands[last].every((c) => cardRank(c) === 14)) {
+      t.turn = last;
+      return t;
     }
+    if (last !== void 0) {
+      t.letters[last]++;
+      t.loser = last;
+      t.result = `Player ${last + 1} receives ${"PAN".slice(0, t.letters[last])}.`;
+    } else t.result = "Round drawn: everyone shed their cards.";
+    t.phase = last !== void 0 && t.letters[last] >= 3 ? "finished" : "round";
+    t.winner = t.phase === "finished" && t.hands.length === 2 ? 1 - last : null;
+    t.turn = last ?? seat;
     return t;
   }
-  throw Error("Choose a legal draw, discard or knock.");
+  do {
+    t.turn = (t.turn + 1) % t.hands.length;
+  } while (!t.hands[t.turn].length);
+  return t;
 }
-function ginView(s, seat) {
-  const { stock, ...rest } = s;
+function panView(s, seat) {
   return {
-    ...rest,
-    stockCount: stock.length,
+    ...s,
     hands: s.hands.map(
-      (h, i) => i === seat || ["round", "finished"].includes(s.phase) ? h : h.map(() => null)
+      (h, i) => i === seat || s.phase !== "play" ? h : h.map(() => null)
     )
   };
 }
 
+// lib/multiplayer/adapters/pan.ts
+var adapter27 = defineMatchAdapter({
+  ranking: (state, count) => loserResult(count, state.loser),
+  actions: ["next", "play", "take"],
+  create(count, entropy2, _goSize) {
+    return createPan(count, entropy2);
+  },
+  turn: (state) => state.turn,
+  outcome(state) {
+    return {
+      finished: state.phase === "finished",
+      winner: state.winner,
+      label: state.result
+    };
+  },
+  apply(state, _seat, action, entropy2, _now) {
+    return playPan(state, action.type, action.cards ?? [], entropy2);
+  },
+  view(state, seat) {
+    return panView(state, seat);
+  }
+});
+
 // lib/multiplayer/adapters/gin-rummy.ts
 var adapter28 = defineMatchAdapter({
   actions: ["next", "pass", "stock", "upcard", "discard", "knock"],
@@ -11356,7 +11501,7 @@ var adapter28 = defineMatchAdapter({
 // lib/multiplayer/sixty-six.ts
 var sixtyStrength = (c) => [9, 11, 12, 13, 10, 14].indexOf(cardRank(c));
 var sixtyPoints = (c) => [0, 2, 3, 4, 10, 11][sixtyStrength(c)];
-function deal13(dealer, scores, round, entropy2) {
+function deal13(dealer, scores2, round, entropy2) {
   const deck = shuffled(
     Array.from({ length: 52 }, (_, i) => i).filter((c) => cardRank(c) >= 9),
     entropy2
@@ -11378,7 +11523,7 @@ function deal13(dealer, scores, round, entropy2) {
     points: [0, 0],
     pending: [0, 0],
     tricks: [0, 0],
-    scores,
+    scores: scores2,
     phase: "play",
     winner: null,
     result: "",
@@ -11548,92 +11693,6 @@ var adapter30 = defineMatchAdapter({
   leave: leavePoker
 });
 
-// lib/multiplayer/dice.ts
-function createDice(count) {
-  if (!index(count - 2, 3)) throw Error("Choose two to four players.");
-  return {
-    dice: [0, 0, 0, 0, 0],
-    held: Array(5).fill(false),
-    rolls: 0,
-    sheets: Array.from({ length: count }, () => Array(13).fill(null)),
-    bonuses: Array(count).fill(0),
-    turn: 0,
-    finished: false,
-    winner: null
-  };
-}
-function diceScore(dice, category, joker = false) {
-  const counts = Array.from(
-    { length: 6 },
-    (_, i) => dice.filter((v) => v === i + 1).length
-  ), sum = dice.reduce((a, b) => a + b, 0);
-  if (category < 6) return counts[category] * (category + 1);
-  switch (category) {
-    case 6:
-      return Math.max(...counts) >= 3 ? sum : 0;
-    case 7:
-      return Math.max(...counts) >= 4 ? sum : 0;
-    case 8:
-      return joker || counts.includes(3) && counts.includes(2) ? 25 : 0;
-    case 9:
-      return joker || [0, 1, 2].some((start) => counts.slice(start, start + 4).every(Boolean)) ? 30 : 0;
-    case 10:
-      return joker || [0, 1].some((start) => counts.slice(start, start + 5).every(Boolean)) ? 40 : 0;
-    case 11:
-      return counts.includes(5) ? 50 : 0;
-    case 12:
-      return sum;
-    default:
-      throw Error("Choose a score category.");
-  }
-}
-function diceTotal(s, seat) {
-  const sheet = s.sheets[seat], upper = sheet.slice(0, 6).reduce((sum, n) => sum + (n ?? 0), 0);
-  return sheet.reduce((sum, n) => sum + (n ?? 0), 0) + (upper >= 63 ? 35 : 0) + s.bonuses[seat];
-}
-function playDice(s, type, at, entropy2) {
-  if (s.finished) throw Error("This match is finished.");
-  if (type === "roll") {
-    if (s.rolls >= 3) throw Error("Record a score after three rolls.");
-    const random = draws(entropy2, 5);
-    return {
-      ...s,
-      rolls: s.rolls + 1,
-      dice: s.dice.map(
-        (v, i) => s.rolls && s.held[i] ? v : 1 + Math.floor(random[i] * 6)
-      )
-    };
-  }
-  if (at === void 0 || !index(at, type === "hold" ? 5 : 13) || !s.rolls)
-    throw Error("Roll first, then choose a die or score category.");
-  if (type === "hold")
-    return { ...s, held: s.held.map((v, i) => i === at ? !v : v) };
-  if (type !== "score" || s.sheets[s.turn][at] !== null)
-    throw Error("Choose an unused score category.");
-  const sheets = s.sheets.map((row) => [...row]), bonuses = [...s.bonuses];
-  const five = s.dice.every((v) => v === s.dice[0]), upper = s.dice[0] - 1;
-  const joker = five && sheets[s.turn][11] !== null && sheets[s.turn][upper] !== null;
-  if (joker && sheets[s.turn].slice(6).some((n) => n === null) && at < 6)
-    throw Error(
-      "Use the five-of-a-kind joker in an unused lower category first."
-    );
-  sheets[s.turn][at] = diceScore(s.dice, at, joker);
-  if (joker && sheets[s.turn][11] === 50) bonuses[s.turn] += 100;
-  const next3 = {
-    ...s,
-    sheets,
-    bonuses,
-    turn: (s.turn + 1) % s.sheets.length,
-    rolls: 0,
-    held: Array(5).fill(false),
-    dice: [0, 0, 0, 0, 0]
-  };
-  next3.finished = sheets.every((row) => row.every((n) => n !== null));
-  if (next3.finished)
-    next3.winner = best(sheets.map((_, i) => diceTotal(next3, i)));
-  return next3;
-}
-
 // lib/multiplayer/adapters/dice.ts
 var adapter31 = defineMatchAdapter({
   ranking: (state) => scoreResult(state.sheets.map((_, seat) => diceTotal(state, seat)), state.winner),
@@ -11688,13 +11747,13 @@ function dominoMoves(s) {
   });
 }
 function endRound(s, winner2, bonus) {
-  const scores = [...s.scores];
-  if (winner2 !== null) scores[winner2] += Math.round(bonus / 5) * 5;
-  const finished = scores.some((n) => n >= 100);
+  const scores2 = [...s.scores];
+  if (winner2 !== null) scores2[winner2] += Math.round(bonus / 5) * 5;
+  const finished = scores2.some((n) => n >= 100);
   return {
     ...s,
-    scores,
-    winner: finished ? best(scores) : null,
+    scores: scores2,
+    winner: finished ? best(scores2) : null,
     phase: finished ? "finished" : "round",
     turn: winner2 ?? s.turn,
     result: winner2 === null ? "Blocked round: equal pip totals." : `Player ${winner2 + 1} wins the round.`
@@ -11710,7 +11769,7 @@ function playDomino(s, type, at, end, entropy2) {
       turn: s.turn
     };
   if (s.phase !== "play") throw Error("This round is finished.");
-  const hands = s.hands.map((h) => [...h]), stock = [...s.stock], chain = [...s.chain], scores = [...s.scores];
+  const hands = s.hands.map((h) => [...h]), stock = [...s.stock], chain = [...s.chain], scores2 = [...s.scores];
   if (type === "draw") {
     if (dominoMoves(s).length)
       throw Error("Play a matching tile before drawing.");
@@ -11735,20 +11794,20 @@ function playDomino(s, type, at, end, entropy2) {
   }
   const left = chain[0], right = chain.at(-1);
   const total = chain.length === 1 ? left[0] + left[1] : (left[0] === left[1] ? left[0] * 2 : left[0]) + (right[0] === right[1] ? right[1] * 2 : right[1]);
-  if (total % 5 === 0) scores[s.turn] += total;
+  if (total % 5 === 0) scores2[s.turn] += total;
   const next3 = {
     ...s,
     hands,
     stock,
     chain,
-    scores,
+    scores: scores2,
     passes: 0,
     turn: 1 - s.turn
   };
   if (!hands[s.turn].length)
     return endRound(next3, s.turn, pipSum(hands[1 - s.turn]));
-  if (scores.some((n) => n >= 100))
-    return { ...next3, phase: "finished", winner: best(scores) };
+  if (scores2.some((n) => n >= 100))
+    return { ...next3, phase: "finished", winner: best(scores2) };
   return next3;
 }
 function dominoView(s, seat) {
@@ -11966,11 +12025,12 @@ function playRummy(s, seat, a, entropy2) {
     return t;
   }
   if (s.phase !== "meld") throw Error("Draw from the stock or take the top discard first.");
-  if (a.type === "meld" && ownedCards(s.hands[seat], a.cards) && a.cards.length < s.hands[seat].length && rummyMeld(a.cards)) {
+  const keepsDiscard = (cards) => s.hands[seat].some((c) => !cards.includes(c) && c !== s.taken);
+  if (a.type === "meld" && ownedCards(s.hands[seat], a.cards) && keepsDiscard(a.cards) && rummyMeld(a.cards)) {
     t.melds.push({ seat, cards: [...a.cards].sort((a2, b) => rummyRank(a2) - rummyRank(b)) });
     t.hands[seat] = t.hands[seat].filter((c) => !a.cards.includes(c));
     t.result = `Player ${seat + 1} melds ${a.cards.length} cards.`;
-  } else if (a.type === "layoff" && index(a.at, s.melds.length) && ownedCards(s.hands[seat], a.cards) && a.cards.length < s.hands[seat].length && rummyMeld([...s.melds[a.at].cards, ...a.cards])) {
+  } else if (a.type === "layoff" && index(a.at, s.melds.length) && ownedCards(s.hands[seat], a.cards) && keepsDiscard(a.cards) && rummyMeld([...s.melds[a.at].cards, ...a.cards])) {
     t.melds[a.at].cards.push(...a.cards);
     t.melds[a.at].cards.sort((a2, b) => rummyRank(a2) - rummyRank(b));
     t.hands[seat] = t.hands[seat].filter((c) => !a.cards.includes(c));
@@ -12062,7 +12122,8 @@ var promotions = ["marriage", "marriage-claim", "makao", "normal", "schneider",
 function hand(state, seat) {
   for (const key2 of ["hands", "hand"]) {
     const hands = state[key2];
-    if (Array.isArray(hands) && Array.isArray(hands[seat])) return hands[seat].filter((c) => typeof c === "number" && c >= 0);
+    const held = typeof state.playSeat === "number" && state.turn === seat ? state.playSeat : seat;
+    if (Array.isArray(hands) && Array.isArray(hands[held])) return hands[held].filter((c) => typeof c === "number" && c >= 0);
   }
   return [];
 }
@@ -12133,8 +12194,13 @@ function specific(game, state, seat) {
     const s = state;
     return s.die ? ludoMoves(s).map((at) => ({ type: "move", at })) : [{ type: "roll" }];
   }
+  if (game === "makao") return [...generic(adapters.makao, state, seat), ...cardGroups(hand(state, seat)).flatMap((cards) => [
+    { type: "play", cards, promotion: "makao" },
+    ...[0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 13].flatMap((amount) => [{ type: "play", cards, amount }, { type: "play", cards, amount, promotion: "makao" }])
+  ])];
   if (game === "go") {
     const s = state;
+    if (s.phase === "scoring" && s.accepted.includes(seat)) return [];
     if (s.phase === "scoring") return [...s.board.flatMap((p, at) => p ? [{ type: "dead", at }] : []), { type: "accept", scoreKey: goProposalKey(s) }, { type: "resume" }];
     return s.phase === "play" && s.turn === seat ? [...s.board.flatMap((p, at) => p ? [] : [{ type: "place", at }]), { type: "pass" }] : [];
   }
@@ -12188,7 +12254,7 @@ function reconstruct(game, view, seat) {
   const own = view.ownFleet, fired = view.fired, incoming = view.incoming;
   return { ...view, fleets: seat === 0 ? [own, []] : [[], own], shots: seat === 0 ? [fired, incoming] : [incoming, fired] };
 }
-var entropy = Array.from({ length: 128 }, (_, i) => i * 7919 + 1);
+var entropy = Array.from({ length: 512 }, (_, i) => i * 7919 + 1);
 function hydrate(adapter36, view, seats2) {
   let template;
   try {
@@ -12231,6 +12297,35 @@ function millsBoard(board) {
     legend: "Each point shows its index then X (seat 0), O (seat 1) or . (empty). Lines connect neighbours along each ring and the midpoints 1-9-17, 3-11-19, 5-13-21, 7-15-23; mills are three in a line."
   };
 }
+function battleshipsBoard(v) {
+  const ships = new Set(v.ownFleet.flat()), sunk = new Set(v.sunk.flat());
+  const target = (at) => sunk.has(at) ? "#" : v.hits.includes(at) ? "x" : v.fired.includes(at) ? "o" : ".";
+  const fleet = (at) => ships.has(at) ? v.incoming.includes(at) ? "X" : "S" : v.incoming.includes(at) ? "o" : ".";
+  const row = (r, cell) => Array.from({ length: 10 }, (_, c) => cell(r * 10 + c)).join(" ");
+  return {
+    rows: 10,
+    columns: 10,
+    labeled: [
+      `    target grid           your fleet`,
+      `   +0 1 2 3 4 5 6 7 8 9  +0 1 2 3 4 5 6 7 8 9`,
+      ...Array.from({ length: 10 }, (_, r) => `${String(r * 10).padStart(2)}  ${row(r, target)}   ${row(r, fleet)}`)
+    ],
+    legend: "Target grid: x hit, # sunk ship, o miss, . not fired. Your fleet: S ship, X hit ship, o enemy miss. Index = row label + column offset."
+  };
+}
+function backgammonBoard(v) {
+  const cell = (at) => `${String(at).padStart(2)}:${v.points[at] ? `${Math.abs(v.points[at])}${v.points[at] > 0 ? "X" : "O"}` : "."}`.padEnd(6);
+  return {
+    rows: 2,
+    columns: 12,
+    labeled: [
+      Array.from({ length: 12 }, (_, i) => cell(12 + i)).join(" ").trimEnd(),
+      Array.from({ length: 12 }, (_, i) => cell(11 - i)).join(" ").trimEnd(),
+      `bar: X ${v.bar[0]}, O ${v.bar[1]} \xB7 off: X ${v.off[0]}/15, O ${v.off[1]}/15`
+    ],
+    legend: "index:count then X (seat 0, moves 0\u219223, bears off past 23 to 24) or O (seat 1, moves 23\u21920, bears off to 24). from -1 enters from the bar. Index + 1 is the point number the browser shows."
+  };
+}
 function fenBoard(fen) {
   const ranks = fen.split(" ")[0].split("/").map((rank2) => rank2.replace(/\d/g, (n) => ".".repeat(Number(n))));
   return {
@@ -12243,6 +12338,8 @@ function fenBoard(fen) {
 function indexedBoard(game, state) {
   const grid = grids[game], board = state?.board;
   if (game === "mills" && Array.isArray(board) && board.length === 24) return millsBoard(board);
+  if (game === "backgammon" && state && typeof state === "object" && "points" in state) return backgammonBoard(state);
+  if (game === "battleships" && state && typeof state === "object" && "ownFleet" in state) return battleshipsBoard(state);
   const fen = state?.fen;
   if ((game === "atomic-chess" || game === "three-check") && typeof fen === "string") return fenBoard(fen);
   if (!grid || !Array.isArray(board)) return null;
@@ -12304,11 +12401,35 @@ function agentPosition(room) {
       if (match.kind === "hex" && match.state.moves === 1 && match.state.turn === 1) legal.push({ type: "swap" });
     }
   }
-  const last = match?.kind === "connect-four" || match?.kind === "tic-tac-toe" || match?.kind === "gomoku" ? match.state.last : null;
-  const yours = room.phase === "playing" && !!match && turn === room.seat && !room.players[room.seat].left && !ended && !room.players.some((p) => p.paused);
+  const last = match?.kind === "connect-four" || match?.kind === "tic-tac-toe" || match?.kind === "gomoku" ? match.state.last : match?.kind === "reversi" || match?.kind === "hex" ? match.state.last ?? null : null;
+  const agreed = match?.kind === "go" && match.state.phase === "scoring" && match.state.accepted.includes(room.seat);
+  const yours = room.phase === "playing" && !!match && turn === room.seat && !agreed && !room.players[room.seat].left && !ended && !room.players.some((p) => p.paused);
   const active = room.phase === "playing" && !!match && !room.players[room.seat].left && !ended && !room.players.some((p) => p.paused);
   const grid = !complete && match ? indexedBoard(room.game, match.state) : null;
   const wire = !complete && match && enumeratedAgentGames.includes(room.game) ? active ? agentLegalActions(room.game, match.state, room.seat, room.capacity) ?? [] : [] : null;
+  const checkerLast = match?.kind === "checkers" || match?.kind === "brazilian-checkers" ? checkerLastMove(match.state.history) : null;
+  const dotsLabeled = match?.kind === "dots-boxes" ? match.state.boxes.map((owner4, box) => {
+    const { size, edges } = match.state, sides2 = boxEdges(size, box), drawn = sides2.filter((e) => edges[e] >= 0).length;
+    const named = ["top", "bottom", "left", "right"].map((side2, i) => `${side2} ${sides2[i] + 1}${edges[sides2[i]] >= 0 ? "*" : ""}`).join(", ");
+    return `box row ${Math.floor(box / size) + 1} col ${box % size + 1} [${owner4 < 0 ? "." : "XO"[owner4]}]: ${named}${owner4 < 0 && drawn === 3 ? " (three sides: takeable)" : ""}`;
+  }) : null;
+  const ginHand = match?.kind === "gin-rummy" && match.state.phase !== "finished" ? match.state.hands[room.seat]?.filter((c) => c !== null) ?? [] : [];
+  const ginHint = ginHand.length ? (() => {
+    const layout = ginLayout(ginHand), names = (cards) => cards.map((c) => `${cardLabel(c)} (id ${c})`);
+    const discards = ginHand.length > 10 ? ginHand.map((c) => ({ discard: c, deadwood: ginLayout(ginHand.filter((x) => x !== c)).value })).sort((a, b) => a.deadwood - b.deadwood) : [];
+    return {
+      deadwood: layout.value,
+      melds: layout.melds.map(names),
+      deadwood_cards: names(layout.deadwood),
+      ...discards.length ? { best_discard: `${cardLabel(discards[0].discard)} (id ${discards[0].discard})`, deadwood_after_best_discard: discards[0].deadwood } : {},
+      knock_limit: 10
+    };
+  })() : null;
+  const asianMove = match?.kind === "shogi" || match?.kind === "xiangqi" ? asianLastMove(match.state.history) : null;
+  const asianLast = asianMove && (match?.kind === "shogi" || match?.kind === "xiangqi") ? { ...asianMove, by: match.state.history.at(-1).mover } : null;
+  const millLast = match?.kind === "mills" ? millLastTurn(match.state) : null;
+  const cribbageCard = match?.kind === "cribbage" && match.state.phase === "peg" ? match.state.sequence.at(-1) : void 0;
+  const cribbageLast = match?.kind === "cribbage" && cribbageCard !== void 0 ? { by_seat: match.state.played.findIndex((cards) => cards.includes(cribbageCard)), played: `${cribbageLabel(cribbageCard)} (id ${cribbageCard})`, count: match.state.total } : null;
   return {
     protocol_version: 1,
     room: room.code,
@@ -12323,15 +12444,16 @@ function agentPosition(room) {
     players: room.players.map((p, seat) => ({ seat, name: p.name, left: p.left, ...p.agent ? { agent: true } : {}, ...p.paused ? { paused: true } : {} })),
     board_size: complete ? { rows, columns } : grid ? { rows: grid.rows, columns: grid.columns } : { rows: 0, columns: 0 },
     board_top_to_bottom: board,
-    board_labeled: labeledBoard(room.game, board) ?? grid?.labeled ?? null,
-    ...grid ? { board_legend: grid.legend } : {},
+    board_labeled: dotsLabeled ?? (match?.kind === "oware" ? [...labeledBoard(room.game, board) ?? [], `captured: seat 0 ${match.state.scores[0]}, seat 1 ${match.state.scores[1]}`] : null) ?? labeledBoard(room.game, board) ?? grid?.labeled ?? null,
+    ...grid ? { board_legend: grid.legend } : dotsLabeled ? { board_legend: "One line per box: owner (X seat 0, O seat 1, . open), then its four edges as one-based edge numbers (--edge N); * marks a drawn edge. A box with three drawn edges can be taken now." } : {},
     // Chess and its variants record the last move in SAN.
-    last_move: (match?.kind === "chess" || match?.kind === "atomic-chess" || match?.kind === "three-check") && match.state.last ? { san: match.state.last } : last === null ? null : room.game === "connect-four" ? { column: last % columns + 1, row_from_top: Math.floor(last / columns) + 1 } : { row: Math.floor(last / columns) + 1, column: last % columns + 1 },
+    last_move: (match?.kind === "chess" || match?.kind === "atomic-chess" || match?.kind === "three-check") && match.state.last ? { san: match.state.last } : checkerLast ? { from: square(checkerLast.from), to: square(checkerLast.to) } : cribbageLast ? cribbageLast : asianLast ? { by_seat: asianLast.by, ...asianLast.from === null ? { type: "drop" } : { from: asianLast.from }, to: asianLast.to } : match?.kind === "oware" && match.state.last !== null ? { last_seed_in_pit: match.state.last + 1 } : millLast ? { by_seat: millLast.seat, ...millLast.from === null ? { type: "place" } : { type: "move", from: millLast.from }, at: millLast.to, ...millLast.captured.length ? { captured: millLast.captured } : {} } : last === null ? null : room.game === "connect-four" ? { column: last % columns + 1, row_from_top: Math.floor(last / columns) + 1 } : { row: Math.floor(last / columns) + 1, column: last % columns + 1 },
     ...room.game === "chess" ? { fen } : {},
     // The side to move is in check (chess family, xiangqi, shogi).
     ...match && room.phase === "playing" && (match.kind === "chess" ? chessPosition(match.state).inCheck() : "check" in match.state && match.state.check === true) ? { in_check: true } : {},
     visible_state: match?.state ?? null,
     cards_labeled: match ? cardsLabeled(room.game, match.state) : null,
+    ...ginHint ? { gin_deadwood: ginHint } : {},
     // Timed rounds (drawing, categories): agents cannot measure time, so give the remaining seconds.
     ...typeof match?.state?.deadline === "number" && room.serverNow ? { deadline_seconds_left: Math.max(0, Math.ceil((match.state.deadline - room.serverNow) / 1e3)) } : {},
     action_types: action_catalog_default[room.game],
@@ -12339,7 +12461,8 @@ function agentPosition(room) {
     legal_actions_complete: complete,
     legal_actions: yours ? legal : [],
     ...match?.kind === "amazons" || match?.kind === "lines-of-action" || match?.kind === "last-greenhouse" || match?.kind === "euchre" || match?.kind === "cribbage" || match?.kind === "fanorona" ? { legal_wire_actions_complete: true, legal_wire_actions: yours ? match.state.legalActions : [] } : wire ? { legal_wire_actions_complete: agentListComplete(room.game, match?.state, wire), legal_wire_actions: wire } : {},
-    outcome: room.outcome ? { winner: room.outcome.winner, label: room.outcome.label } : null,
+    // Engine labels count players from 1; name the zero-based seat as everywhere else in the CLI.
+    outcome: room.outcome ? { winner: room.outcome.winner, label: room.outcome.label.replace(/Player (\d+)/g, (whole, n) => room.players[Number(n) - 1] ? `seat ${Number(n) - 1} (${room.players[Number(n) - 1].name})` : whole) } : null,
     instructions_for_resume: "Resume your agent chat with this room code and read status. A timeout is not resignation. To rematch, use game rematch; never start one without the human asking.",
     terminal_reason: room.phase === "finished" ? room.players.some((p) => p.left) ? "resignation_or_leave" : "game_result" : null,
     rematch_ready: room.rematch.includes(room.seat),
@@ -12347,17 +12470,23 @@ function agentPosition(room) {
   };
 }
 function labeledBoard(game, board) {
-  if (!board?.length || game === "oware" || game === "dots-boxes") return null;
+  if (!board?.length || game === "dots-boxes") return null;
+  if (game === "oware") return [`seat 0 pits 1-6:  ${board[0]}`, `seat 1 pits 7-12: ${board[1]}`, "Sowing runs 1\u219212 and wraps to 1, skipping the origin pit after a full lap."];
   const algebraic = game === "chess" || game === "checkers";
   const rowWidth = String(board.length).length, cell = algebraic ? 1 : String(board[0].length).length;
   const files2 = algebraic ? [..."abcdefgh"] : [...board[0]].map((_, c) => String(c + 1));
   return [
     `${" ".repeat(rowWidth)} ${files2.map((f) => f.padStart(cell)).join(" ")}`,
-    ...board.map((row, r) => `${String(algebraic ? board.length - r : r + 1).padStart(rowWidth)} ${[...row].map((p) => p.padStart(cell)).join(" ")}`)
+    // Hex rows shift right one step per row, so the six neighbours sit around each cell.
+    ...board.map((row, r) => `${String(algebraic ? board.length - r : r + 1).padStart(rowWidth)} ${game === "hex" ? " ".repeat(Math.round(r * (cell + 1) / 2)) : ""}${[...row].map((p) => p.padStart(cell)).join(" ")}`)
   ];
 }
 function agentMove(position, input) {
   const action = position.legal_actions.find((a) => a.type === "swap" ? input.swap === true && Object.entries(input).every(([k, v]) => k === "swap" || v === void 0) : a.type === "edge" ? input.edge === a.edge && Object.entries(input).every(([k, v]) => k === "edge" || v === void 0) : a.type === "sow" ? input.pit === a.pit && Object.entries(input).every(([k, v]) => k === "pit" || v === void 0) : !input.swap && input.edge === void 0 && input.pit === void 0 && a.type === "move" ? input.column === void 0 && input.row === void 0 && a.from === input.from && a.to === input.to && a.promotion === input.promotion : a.type === "place" || a.type === "drop" ? !input.swap && input.edge === void 0 && input.pit === void 0 && input.from === void 0 && input.to === void 0 && input.promotion === void 0 && a.column === input.column && (a.type === "drop" ? input.row === void 0 : a.row === input.row) : false);
+  if (!action && input.from !== void 0 && input.to !== void 0 && "legal_wire_actions" in position) {
+    const wire = position.legal_wire_actions?.find((a) => a.type === "move" && String(a.from) === input.from && String(a.to) === input.to && (a.promotion === void 0 || a.promotion === input.promotion));
+    if (wire) return wire;
+  }
   if (!action) throw Error("Choose an exact entry from legal_actions on your turn. Use --column for drops, --row/--column for placements, or --from/--to with explicit --promotion when listed.");
   if (action.type === "swap") return { type: "swap" };
   if (action.type === "edge") return { type: "place", at: action.edge - 1 };
@@ -12371,7 +12500,7 @@ function agentRules(game = "connect-four") {
   const rules = {
     "connect-four": "Drop into an unfilled column. Gravity places the piece in the lowest empty cell. Four or more matching pieces horizontally, vertically or diagonally wins; a full board without a winner draws.",
     chess: "Standard chess, including castling, en passant, check, checkmate, stalemate, repetition and fifty-move draws. Seat 0 is White. Pick a listed from/to move. Promotions explicitly list q, r, b and n; supply --promotion. FEN is included for complete castling and en passant state.",
-    checkers: "English draughts on 8 by 8. Seat 0 moves from the bottom towards row 1. Captures are compulsory; kings move one diagonal square in either direction. A multiple jump is submitted one step at a time: read status and continue with the same piece while it remains your turn. Crowning ends a turn. No pieces or no legal moves loses; repetition and 80 quiet half-moves draw.",
+    checkers: "English draughts on 8 by 8. Seat 0 (x) starts on ranks 1\u20133 at the bottom and moves up towards rank 8; seat 1 (o) moves down. Men move and capture forward only, as in English draughts. Captures are compulsory; kings move one diagonal square in either direction. A multiple jump is submitted one step at a time: read status and continue with the same piece while it remains your turn. Crowning ends a turn. No pieces or no legal moves loses; repetition and 80 quiet half-moves draw.",
     "tic-tac-toe": "X (seat 0) starts on a 3 by 3 board. Place on an empty square. Three matching marks horizontally, vertically or diagonally wins; a full board without a winner draws.",
     reversi: "Bracket opposing discs in a straight line; all bracketed discs flip. Seat 0 is Black and starts. The engine automatically skips players with no legal move; the same seat may move twice. No pass command is needed. When neither can move, the most discs wins; equal counts draw.",
     hex: "Connect opposite edges on the hexagonal board: seat 0 top to bottom, seat 1 left to right. On seat 1's first turn it may swap; this transposes the first stone and changes its owner. No draws.",
@@ -12379,7 +12508,7 @@ function agentRules(game = "connect-four") {
     oware: "Sow the seeds from a nonempty pit on your side, skipping the origin after a full lap. Feed an empty opponent if possible. Capture opposing pits with two or three seeds, except when doing so would starve the opponent. Scores, feeding and end conditions follow the supplied rules and state.",
     gomoku: "Place on an empty intersection of the 15 by 15 board. Exactly five contiguous stones horizontally, vertically or diagonally wins. A line longer than five does not win in this variant. A full board without a winner draws."
   };
-  const coordinates = !completeAgentGames.includes(game) || game === "dots-boxes" || game === "oware" ? actionHelp(game).indexing : game === "hex" ? "One-based rows and columns on the size in visible_state. Use --swap only when listed. Seat 0 connects top/bottom; seat 1 left/right." : game === "chess" ? "Use --from e2 --to e4. Board rows are ranks 8 to 1, columns a to h. Uppercase pieces are White, lowercase Black; dot is empty. FEN describes the full position." : game === "checkers" ? "Use --from b3 --to a4. Board rows are ranks 8 to 1, columns a to h. x/X are seat 0 men/kings; o/O are seat 1 men/kings; dot is empty." : game === "connect-four" ? "Columns are 1\u20137, left to right; use --column. X is seat 0, O is seat 1, dot is empty." : `Rows and columns are 1\u2013${game === "reversi" ? 8 : game === "gomoku" ? 15 : 3}, top to bottom and left to right; use --row and --column. X is seat 0, O is seat 1, dot is empty.`;
+  const coordinates = !completeAgentGames.includes(game) || game === "dots-boxes" || game === "oware" ? actionHelp(game).indexing : game === "hex" ? "One-based rows and columns on the size in visible_state. Use --swap only when listed. Seat 0 (X, Black) connects top/bottom; seat 1 (O, White) left/right. board_labeled indents each row one step, so (r,c) touches the six cells (r,c-1), (r,c+1), (r-1,c), (r-1,c+1), (r+1,c-1) and (r+1,c)." : game === "chess" ? "Use --from e2 --to e4. Board rows are ranks 8 to 1, columns a to h. Uppercase pieces are White, lowercase Black; dot is empty. FEN describes the full position." : game === "checkers" ? "Use --from b3 --to a4. Board rows are ranks 8 to 1, columns a to h. x/X are seat 0 men/kings; o/O are seat 1 men/kings; dot is empty." : game === "connect-four" ? "Columns are 1\u20137, left to right; use --column. X is seat 0, O is seat 1, dot is empty." : `Rows and columns are 1\u2013${game === "reversi" ? 8 : game === "gomoku" ? 15 : 3}, top to bottom and left to right; use --row and --column. X is seat 0, O is seat 1, dot is empty.`;
   return { protocol_version: 1, game, rules: multiplayerGames.find((g) => g.id === game).rules, guidance: rules[game] ?? "Use the player-visible state and documented wire actions. The server validates legality; an empty partial action list does not mean there are no legal moves.", action_types: action_catalog_default[game], action_help: actionHelp(game), coordinates, instructions };
 }
 var connectFourAgentRules = agentRules();
@@ -12558,6 +12687,7 @@ function networkCause(error) {
 var readRoom = (session, signal) => rpc(session, "read", {}, true, signal);
 var continuousGames = ["draw-guess", "categories"];
 function waitForRoom(session, after, seconds, signal, untilAction = false) {
+  const sawRevision = after !== void 0;
   return new Promise((resolve, reject) => {
     let socket, closed = false, reconnects = 0, received = false, opened = false;
     let ping, retry;
@@ -12599,7 +12729,7 @@ function waitForRoom(session, after, seconds, signal, untilAction = false) {
           received = true;
           after ??= latest.revision;
           if (latest.revision < after) throw new ServiceError("Your revision is ahead of this room. Read game status again.", "STALE_REVISION");
-          const canAct2 = !continuousGames.includes(latest.game) && (latest.turn?.yours || !!(latest.legal_wire_actions_complete && latest.legal_wire_actions?.length));
+          const canAct2 = !continuousGames.includes(latest.game) && (latest.turn?.yours || !sawRevision && !!(latest.legal_wire_actions_complete && latest.legal_wire_actions?.length));
           if (untilAction && latest.revision > after && !canAct2 && latest.phase !== "finished" && !latest.you.left && !latest.paused) after = latest.revision;
           if (latest.revision > after || canAct2 || latest.phase === "finished" || latest.you.left || latest.paused) finish6({ event: latest.phase === "finished" ? "finished" : latest.you.left ? "left" : latest.paused ? "paused" : latest.turn?.yours ? "your_turn" : canAct2 ? "can_act" : "changed", position: latest });
         } catch (error) {
@@ -12665,11 +12795,19 @@ function nextStep(position, event, brief = false, server) {
   const play = (move2) => `leafarcade game play ${room} --revision ${revision} --action ${move2}`;
   if (wire?.length && !position.turn?.yours) return `You may act now (phase action outside the normal turn): ${play("'<one legal_wire_actions entry>'")}${flag}. Otherwise wait: ${wait}`;
   if (position.turn?.yours) {
-    if (wire?.length === 1 && wire[0].type === "next" && Object.keys(wire[0]).length === 1) return `The hand is over; you deal the next one: ${play(`'{"type":"next"}'`)} --wait${flag}`;
+    if (wire?.length === 1 && wire[0].type === "next" && Object.keys(wire[0]).length === 1) return `The hand is over; start the next one (the deal moves on): ${play(`'{"type":"next"}'`)} --wait${flag}`;
     const partial = !wire && position.legal_wire_actions?.length ? "Some legal actions are listed in legal_wire_actions, but the list is not exhaustive (see game rules for melds, offers, amounts or card groups). " : "";
     const move2 = wire ? "'<one legal_wire_actions entry>'" : position.legal_actions_complete ? "'<one legal_actions entry>'" : "'<wire action JSON from game rules>'";
     const check = lineGames.includes(position.game) ? "Check your immediate win and your opponent's immediate threats (every line, including diagonals), then: " : "";
-    return `Your move. ${partial}${check}${play(move2)} --wait${flag}`;
+    const makao = position.game === "makao" ? ((state) => [
+      state?.penalty ? `A ${state.penalty}-card penalty is active: answer with a matching attack card, or draw takes all ${state.penalty}. ` : "",
+      state?.wait ? `A ${state.wait}-turn wait is active: answer with a 4, or draw serves the wait (no cards drawn). ` : "",
+      state?.blocked?.[position.you.seat] ? `You are blocked for ${state.blocked[position.you.seat]} more turn(s). ` : "",
+      state?.demand !== null && state?.demand !== void 0 ? `Jack demand in force: ${state.demand === 13 ? "king" : `rank ${state.demand}`}. ` : "",
+      state?.suit !== null && state?.suit !== void 0 ? `Ace suit in force: ${["clubs", "diamonds", "hearts", "spades"][state.suit]}. ` : ""
+    ].join(""))(position.visible_state) : "";
+    const mill = position.game === "mills" && wire?.length && wire.every((action) => action.type === "capture") ? "You completed a mill: remove one opposing piece (only pieces outside mills, unless all are in mills). " : "";
+    return `Your move. ${mill}${makao}${partial}${check}${play(move2)} --wait${flag}`;
   }
   if (event === "waiting") return `No change yet. If the other players are still playing, wait again: ${wait}. After several silent waits, stop and tell the human how to resume.`;
   const outOfTurn = position.legal_actions_complete || position.legal_wire_actions_complete ? "" : " Some phases allow out-of-turn actions; check game rules for this phase first.";
@@ -12761,7 +12899,7 @@ async function installSkill(agent = "codex", update = false) {
 // packages/cli/package.json
 var package_default = {
   name: "@leafarcade/cli",
-  version: "0.7.0",
+  version: "0.8.0",
   private: false,
   description: "Create private browser board games and play with your AI agent. Includes 53 games and an installable Codex/Claude skill.",
   type: "module",
@@ -12822,7 +12960,7 @@ var commands = {
   status: { usage: "game status --room ROOMCODE", description: "Read your seat's visible state, phase, turn, revision, outcome and action completeness. Hidden information belonging to other players stays hidden. Includes a labeled board, last_move and a concrete next command.", options: ["room", "brief", "server"] },
   "legal-actions": { usage: "game legal-actions --room ROOMCODE", description: "Read actions and legal_actions_complete. An empty partial list is not proof that no move exists. Use game rules and visible_state for JSON actions.", options: ["room", "server"] },
   play: { usage: "game play --room ROOMCODE --revision R MOVE_FLAGS [--wait]", description: "Submit one move at the exact latest revision. Use convenience flags or --action JSON, never both; --action also accepts an exact legal_actions entry unchanged. --wait then waits for your next turn or the end, like game wait. The service validates legality. On stale or uncertain results, read status before acting again.", options: ["room", "revision", "action", "column", "row", "from", "to", "promotion", "swap", "edge", "pit", "wait", "timeout", "brief", "server"] },
-  wait: { usage: "game wait --room ROOMCODE [--after-revision R] [--timeout 90]", description: "Wait for changes through WebSocket (1\u20133600 seconds, default 90). Without --after-revision it waits for the next change after the current one. Returns at once when you can already act. Returns your_turn, can_act (a phase action outside your turn), changed, paused, finished, left or waiting. Use it after every move instead of asking the human to report theirs. A timeout is normal, not resignation. This command cannot restart a stopped agent.", options: ["room", "after-revision", "timeout", "brief", "server"] },
+  wait: { usage: "game wait --room ROOMCODE [--after-revision R] [--timeout 90]", description: "Wait for changes through WebSocket (1\u20133600 seconds, default 90). Without --after-revision it waits for the next change after the current one. Returns at once when it is already your turn; optional phase actions outside your turn (such as a challenge window) return at once only without --after-revision, so you can wait through them. Returns your_turn, can_act (a phase action outside your turn), changed, paused, finished, left or waiting. Use it after every move instead of asking the human to report theirs. A timeout is normal, not resignation. This command cannot restart a stopped agent.", options: ["room", "after-revision", "timeout", "brief", "server"] },
   pause: { usage: "game pause --room ROOMCODE --revision R", description: "Save your explicit pause in an active, unclocked private match. Any paused player blocks moves. Room expiry is not extended.", options: ["room", "revision", "brief", "server"] },
   resume: { usage: "game resume --room ROOMCODE --revision R", description: "Clear your own pause. Each player who paused must resume before play continues.", options: ["room", "revision", "brief", "server"] },
   rematch: { usage: "game rematch --room ROOMCODE --revision R", description: "Request another round after a normal finish. All players must agree and remain at the table. After resignation or leaving, create a fresh room. Never request a rematch without the human asking.", options: ["room", "revision", "brief", "server"] },
@@ -12958,7 +13096,7 @@ Coordinates
 Actions
   ${rules.action_types.join(", ")}
   ${rules.action_help.game}
-  ${complete ? "Complete legal-action list: choose an exact legal_actions entry on your turn (pass it to --action unchanged, or use the flags)." : wireListed.includes(game) ? "Complete legal_wire_actions list in status, including phase actions outside your turn: pass one entry to --action unchanged. Card names are in cards_labeled." : "Partial legal-action list: inspect visible_state and game phase; use --action JSON. An empty list does not mean there are no moves."}
+  ${complete ? "Complete legal-action list: choose an exact legal_actions entry on your turn (pass it to --action unchanged, or use the flags)." : wireListed.includes(game) ? `Complete legal_wire_actions list in status, including phase actions outside your turn: pass one entry to --action unchanged.${hasCardLabels(game) ? " Card names are in cards_labeled." : ""}` : "Partial legal-action list: inspect visible_state and game phase; use --action JSON. An empty list does not mean there are no moves."}
 
 Move syntax example (illustrative; read status and verify legality first)
   leafarcade game play --room ROOMCODE --revision R ${examples[game]} --wait
@@ -13042,6 +13180,11 @@ var show = (value) => JSON.stringify(value)?.slice(0, 120) ?? "undefined";
 function stateChanges(game, before, after, limit = 30) {
   const out2 = [];
   const labels2 = [cardsLabeled(game, before) ?? {}, cardsLabeled(game, after) ?? {}];
+  const names = /* @__PURE__ */ new Map();
+  for (const side2 of labels2) for (const value of Object.values(side2)) for (const label of [value].flat()) {
+    const id = /\(id (\d+)\)$/.exec(label)?.[1];
+    if (id !== void 0) names.set(Number(id), label);
+  }
   const named = (path, value, side2) => {
     const label = labels2[side2][path];
     return label === void 0 ? show(value) : Array.isArray(label) ? label.join(", ") || "[]" : label;
@@ -13062,6 +13205,14 @@ function stateChanges(game, before, after, limit = 30) {
         a.forEach((v, i) => walk(v, b[i], [...path, String(i)]));
         return;
       }
+      const cardName = (card2) => names.get(card2) ?? show(card2);
+      if (labels2[0][here] !== void 0 || labels2[1][here] !== void 0) {
+        const added = b.filter((card2) => !a.includes(card2)), removed = a.filter((card2) => !b.includes(card2));
+        if (added.length + removed.length < Math.max(a.length, b.length)) {
+          out2.push(`${here}: ${[...added.map((c) => `+${cardName(c)}`), ...removed.map((c) => `-${cardName(c)}`)].join(", ")}`);
+          return;
+        }
+      }
       out2.push(`${here}: ${named(here, a, 0)} \u2192 ${named(here, b, 1)}`);
       return;
     }
@@ -13097,7 +13248,16 @@ async function withChanges(result, path) {
   if (!changes.length) return result;
   const boards = [before.state, position.visible_state].map((state) => state?.board);
   const cells = Array.isArray(boards[0]) && Array.isArray(boards[1]) && boards[0].length === boards[1].length ? boards[1].flatMap((value, at) => JSON.stringify(value) === JSON.stringify(boards[0][at]) ? [] : [{ at, before: boards[0][at], after: value }]) : [];
-  const annotated = { ...position, ...position.last_move === null && "board_legend" in position && cells.length && cells.length <= 12 ? { last_move: { board_changes: cells } } : {}, changed_since_last_read: { from_revision: before.revision, changes } };
+  const square2 = (at) => "abcdefgh"[at % 8] + (8 - Math.floor(at / 8));
+  const derived = position.game === "checkers" ? cells.map((cell) => ({ ...cell, at: square2(cell.at) })) : "board_legend" in position ? cells : [];
+  const piles = [before.state, position.visible_state].map((state) => state?.discard);
+  const top = position.game === "gin-rummy" && Array.isArray(piles[0]) && Array.isArray(piles[1]) ? piles[0].at(-1) : void 0;
+  const taken = typeof top === "number" && !piles[1].includes(top) ? `${cardLabel(top)} (id ${top})` : null;
+  const annotated = {
+    ...position,
+    ...position.last_move === null && derived.length && derived.length <= 12 ? { last_move: { board_changes: derived } } : {},
+    changed_since_last_read: { from_revision: before.revision, ...taken ? { taken_from_discard: taken } : {}, changes }
+  };
   return "position" in result ? { ...result, position: annotated } : annotated;
 }
 
@@ -13502,6 +13662,10 @@ var winner = (position) => {
   return seat === void 0 || seat === null ? null : seat === position.you.seat ? "you" : seatName(position, seat);
 };
 var seatName = (position, seat) => `seat ${seat} (${position.players[seat]?.name ?? "empty"})`;
+var scores = (position) => {
+  const value = position.visible_state?.scores;
+  return Array.isArray(value) && value.length && value.every((n) => typeof n === "number") ? value : null;
+};
 function briefPosition(position) {
   const turn = position.turn ? position.turn.yours ? "yours" : seatName(position, position.turn.seat) : null;
   const wire = "legal_wire_actions" in position ? position.legal_wire_actions ?? [] : null;
@@ -13514,6 +13678,8 @@ function briefPosition(position) {
       you: position.you.piece,
       turn,
       ...position.paused ? { paused: true } : {},
+      // Match or capture scores by zero-based seat, when the game keeps them.
+      ...scores(position) ? { scores: scores(position) } : {},
       ..."in_check" in position ? { in_check: true } : {},
       ...position.you.left ? { left: true } : {},
       ...position.phase === "waiting" ? { seated: position.players.filter((player) => !player.left).length, capacity: position.capacity } : {},
@@ -13527,8 +13693,9 @@ function briefPosition(position) {
     ..."deadline_seconds_left" in position ? { deadline_seconds_left: position.deadline_seconds_left } : {},
     ..."board_legend" in position ? { board_legend: position.board_legend } : {},
     // Only the classic convenience games are fully described by their labeled board.
-    ...position.legal_actions_complete || !position.visible_state ? {} : { visible_state: position.visible_state },
+    ...position.legal_actions_complete && position.board_labeled || !position.visible_state ? {} : { visible_state: position.visible_state },
     ...position.cards_labeled ? { cards_labeled: position.cards_labeled } : {},
+    ..."gin_deadwood" in position ? { gin_deadwood: position.gin_deadwood } : {},
     ...position.access_requests?.length ? { access_requests: position.access_requests } : {}
   };
 }
@@ -13678,7 +13845,7 @@ try {
             result = { event: "browser_requested", room, url, browser: await openBrowser(url) };
           } else if (command === "start" || command === "leave" || command === "resign" || command === "rematch" || command === "pause" || command === "resume") {
             const revision = integer(values.revision, "revision", 0, Number.MAX_SAFE_INTEGER);
-            if (revision !== view.revision) throw new ServiceError("The room changed. Read game status before changing the room.", "STALE_REVISION");
+            if (revision !== view.revision) throw new ServiceError(`The room changed (now revision ${view.revision}). Read game status before changing the room.`, "STALE_REVISION");
             if (command === "start") {
               await rpc(session, "start", { revision }, false, controller.signal);
               result = { event: "started", position: agentPosition(await readRoom(session, controller.signal)) };
@@ -13700,7 +13867,7 @@ try {
               const revision = integer(values.revision, "revision", 0, Number.MAX_SAFE_INTEGER);
               const column = values.column === void 0 ? void 0 : integer(values.column, "column", 1, position.board_size.columns);
               const row = values.row === void 0 ? void 0 : integer(values.row, "row", 1, position.board_size.rows);
-              if (revision !== position.revision) throw new ServiceError("The room changed. Read game status before playing.", "STALE_REVISION");
+              if (revision !== position.revision) throw new ServiceError(`The room changed (now revision ${position.revision}). Read game status before playing.`, "STALE_REVISION");
               if (values.action && [values.column, values.row, values.from, values.to, values.promotion, values.edge, values.pit, values.swap].some((v) => v !== void 0)) throw Error("Use --action or convenience flags, not both.");
               const action = values.action ? agentWireMove(position, values.action) : agentMove(position, { column, row, from: values.from, to: values.to, promotion: values.promotion, swap: values.swap, edge: values.edge === void 0 ? void 0 : integer(values.edge, "edge", 1, 1e3), pit: values.pit === void 0 ? void 0 : integer(values.pit, "pit", 1, 12) });
               const waitSeconds = integer(values.timeout ?? String(defaultWaitSeconds), "timeout", 1, 3600);