Mechanics

setup({ players }) {
  return { turn: T.turns.create(players.map((p) => p.id)), ... };
},
moves: {
  pass(s, { playerId }) {
    if (T.turns.current(s.turn) !== playerId) return { error: 'Not your turn' };
    if (T.turns.pass(s.turn)) {             // everyone has passed: next round
      endOfRound(s);
      T.turns.newRound(s.turn, s.turn.passed[0]); // the first to pass starts
    } else T.turns.next(s.turn);
    return s;
  },
},
// Power Grid: the leader goes first; equal cities → the biggest plant
s.turn.order = T.turns.by(s.players, ['cities', 'bestPlant']).map((p) => p.id);

// Splendor-style: reaching 15 lets the round finish, so everyone gets the same number of turns
if (p.vp >= 15) T.flow.endAfterRound(s.flow);
...
if (!T.turns.next(s.turn)) { T.flow.next(s.flow); T.turns.newRound(s.turn); }
endIf: (s) => (s.flow.over ? T.score.result(s.players, { keys: ['vp', '-cards'] }) : null),

moves: {
  playSpy(s, { playerId }) {
    const foes = s.players.filter((p) => p.id !== playerId).map((p) => p.id);
    T.pending.push(s.pending, { playerId, kind: 'spy', options: foes });
    return s;
  },
  choose(s, { playerId, args }) {
    const d = T.pending.resolve(s.pending, playerId, args.choice);
    if (!d) return { error: 'Not a valid choice' };
    if (d.kind === 'spy') peek(s, playerId, d.choice);
    return s;
  },
},
actions(s, { playerId }) {
  if (s.pending.length) return T.pending.actions(s.pending, playerId);
  ...
},

actions: (s, { playerId }) => T.workers.available(s.board, playerId).map((space) => ({ name: 'place', args: { space } })),

actions: (s, { playerId }) => T.rondel.moves(me.pos, 8, { budget: me.coins }).map((m) => ({ name: 'rondel', args: { to: m.to } })),

const r = T.track.move(s, 'temperature', 2, { max: 8, marks: [0, 4] });
for (const m of r.crossed) bonus(s, p, m); // first to raise the temperature past 0 and 4 gets a bonus

accept(s, { playerId, args }) {
  if (!T.trade.accept(s.offers, args.id, playerId, (id) => P(s, id).res)) return { error: 'That trade is not possible' };
  return s;
},
// offers are negotiation: mark them free so bots and the referee don't count them as progress
actions: (s, { playerId }) => T.trade.open(s.offers, playerId).map((o) => ({ name: 'accept', args: { id: o.id }, free: true })),

moves: {
  bid(s, { playerId, args }) {
    if (!T.auction.bid(s.auction, playerId, args.amount)) return { error: 'You cannot bid that now' };
    return settle(s);
  },
  pass(s, { playerId }) { if (!T.auction.pass(s.auction, playerId)) return { error: 'Not your turn' }; return settle(s); },
},
actions(s, { playerId }) {
  if (T.auction.turn(s.auction) !== playerId) return [];
  const bids = T.auction.legalBids(s.auction, playerId, me.money).slice(0, 5); // a few raises are enough for bots
  return [{ name: 'pass' }, ...bids.map((amount) => ({ name: 'bid', args: { amount } }))];
},
// settle(s): if (T.auction.done(s.auction)) { const w = T.auction.winner(s.auction); if (w) buy(s, w.id, w.price); ... }

moves: {
  choose(s, { playerId, args }) {
    if (!T.secret.commit(s.signs, playerId, args.sign)) return { error: 'Too late' };
    if (T.secret.allIn(s.signs)) score(s, T.secret.reveal(s.signs)); // all signs at once
    return s;
  },
},
view(s, { playerId }) {
  const signs = T.secret.view(s.signs, playerId, '?'); // never leak other players' choices
  ...
},
actions: (s, { playerId }) => (T.secret.pending(s.signs).includes(playerId) ? ['rock', 'paper', 'scissors'].map((sign) => ({ name: 'choose', args: { sign } })) : []),

const r = T.vote.result(T.secret.reveal(s.ballot), { need: 'majority' }); // Secret Hitler-style: ja needs a majority
if (r.winner === 'ja') enact(s); else s.failed += 1;

const SEES = { spy: ['spy', 'assassin'], assassin: ['spy', 'assassin'], merlin: { spy: 'evil', assassin: 'evil' } };
setup({ players, random }) {
  const { roles } = T.roles.deal(players.map((p) => p.id), { 5: ['merlin', 'loyal', 'loyal', 'spy', 'assassin'], 6: [...] }, random);
  return { roles, ... };
},
view(s, { playerId }) {
  const known = T.roles.known(s.roles, playerId, SEES); // only what this player may see
  ...
},

buy(s, { playerId, args }) {
  const p = P(s, playerId); const cost = T.market.price(args.slot, [0, 1, 2, 3, 4]);
  if (s.row[args.slot] == null || !T.pay(p.res, { gold: cost })) return { error: 'Cannot buy that' };
  p.cards.push(T.market.take(s.row, args.slot));
  T.market.refill(s.row, 5, s.deck, s.discard, ctx.random);
  return s;
},

// 7 Wonders: everyone picks secretly, then hands are passed
pick(s, { playerId, args }) {
  if (!s.hands[playerId].includes(args.card) || !T.secret.commit(s.picks, playerId, args.card)) return { error: 'Cannot pick that' };
  if (T.secret.allIn(s.picks)) {
    for (const [id, card] of Object.entries(T.secret.reveal(s.picks))) T.draft.pick(s.hands[id], card, P(s, id).tableau);
    T.draft.pass(s.hands, s.order, T.draft.dir(s.age));
    s.picks = T.secret.create(s.order);
  }
  return s;
},

setup: ({ players, random }) => ({ decks: Object.fromEntries(players.map((p) => [p.id, T.deckbuild.create([...STARTER], random, 5)])), ... }),
endTurn(s, ctx) { T.deckbuild.cleanup(s.decks[ctx.playerId], ctx.random, 5); ... },

const OPTS = { order: ['7', '8', '9', '10', 'J', 'Q', 'K', 'A'], trump: 'hearts' };
actions: (s, { playerId }) => T.tricks.legal(hand(s, playerId), s.trick, OPTS).map((card) => ({ name: 'play', args: { card } })),
// when everyone has played: s.leader = T.tricks.winner(s.trick, OPTS).id

const values = ctx.rollMany(T.range(5).map((i) => ({ id: `die${i}` }))).map((r) => r.face); // thrown on the table
const yahtzee = T.dice.matches(values, { groups: [5] }) ? 50 : 0;
const chance = T.dice.odds(3, 6, (d) => d.filter((x) => x === 6).length >= 2); // for a bot: worth re-rolling three?

// Quacks of Quedlinburg: chance that the next chip explodes the pot
const risk = T.bag.odds(s.bag[playerId], 1, (d) => whiteTotal(p) + d.white1 + 2 * d.white2 + 3 * d.white3 > 7);
bot: (s, { actions }) => actions.find((a) => a.name === (risk > 0.3 ? 'stop' : 'draw')),

// Connect Four
const cells = T.grid.rect(7, 6);
const win = T.grid.lineRuns(cells, (k) => s.board[k], 4)[0]; // { value: 'red', cells: [...] } or undefined
// Go: a group without liberties is captured
for (const g of T.grid.regions(cells, (k) => s.board[k] || null)) {
  if (g.value && !g.cells.some((c) => T.grid.neighbors(c).some((n) => s.board[n] === null))) capture(s, g.cells);
}
// Patchwork / Blokus: every legal placement of a piece
const free = (k) => T.grid.inBounds(k, 9, 9) && !s.quilt[k];
actions = T.grid.placements(PIECES[id], cells, free).map((p) => ({ name: 'place', args: { id, at: p.at, shape: p.shape } }));

endIf: (s) => (s.flow.over ? T.score.result(s.players, { keys: ['vp', 'coins', '-seat'] }) : null),

// 7 Wonders science: squares plus 7 per complete set
const c = T.sets.count(p.science);
const science = Object.values(c).reduce((a, n) => a + n * n, 0) + 7 * T.sets.complete(c, ['gear', 'tablet', 'compass']);
// Sushi Go dumplings and sets of different colours
const dumplings = T.score.table(T.sets.count(p.cards).dumpling || 0, [0, 1, 3, 6, 10, 15]);
const colours = T.sets.distinct(T.sets.count(p.cards, 'color')).reduce((a, n) => a + T.score.table(n, [0, 1, 3, 6, 10]), 0);

const tally = T.area.tally(s.pieces, 'region', 'owner');
const pts = T.area.score(tally, (r) => REGION_AWARDS[r], { tie: 'down' });
for (const id of Object.keys(pts)) P(s, id).vp += pts[id];