@pithy-sh/multiplayer 0.1.0

package/src/game/games/craps.ts

@@ -0,0 +1,182 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import { z } from "zod";
+import { MultiplayerInvalidMoveError, MultiplayerInvalidTransitionError } from "../../error/errors";
+import { type BetDecision, type PendingBet, wageringTable } from "../patterns/wageringTable";
+
+/**
+ * Craps — the flagship **wagering-table** game (built on the {@link wageringTable} pattern).
+ *
+ * The pattern owns the wagering plumbing: the bet book, the ledger holds placed when a bet lands, the
+ * settlement when a bet resolves, and the persistent-table lifecycle. Craps supplies only the game: what a
+ * valid bet is, who may roll (the shooter), and how a roll decides each pending bet. The house is the
+ * counterparty for wins and losses — off the players' ledger — so how you fund and book the house edge is
+ * yours, and Pithy takes no position on whether the chips map to money.
+ *
+ * The bets are the three that define craps' structure — a subset, not the whole layout:
+ * - **Pass line** — placed on the come-out. Wins on a come-out 7 or 11, or when the shooter makes the point;
+ *   loses on a come-out 2, 3, or 12, or on a seven-out. Even money.
+ * - **Don't Pass** — the opposite. Wins on a come-out 2 or 3 (12 pushes), or on a seven-out; loses on a
+ *   come-out 7 or 11, or when the point is made. Even money.
+ * - **Field** — a one-roll bet: wins on 2, 3, 4, 9, 10, 11, 12 (2 and 12 pay double), loses on 5, 6, 7, 8.
+ */
+
+export const CrapsConfig = z
+  .object({
+    currency: z
+      .string()
+      .min(1)
+      .describe("The ledger currency bets and payouts are denominated in (from the ledger capability's `currencies`)."),
+    minBet: z.number().int().min(1).default(1).describe("The smallest bet allowed, in the currency's minor unit."),
+    maxBet: z.number().int().min(1).optional().describe("The largest bet allowed, or omit for no cap."),
+  })
+  .describe("The craps table's rules — the betting currency and the bet size limits.")
+  .check((ctx) => {
+    if (ctx.value.maxBet !== undefined && ctx.value.maxBet < ctx.value.minBet)
+      ctx.issues.push({
+        code: "custom",
+        input: ctx.value,
+        path: ["maxBet"],
+        message: `maxBet ${ctx.value.maxBet} is below minBet ${ctx.value.minBet}.`,
+      });
+  });
+export type CrapsConfig = z.output<typeof CrapsConfig>;
+
+export const CrapsBetType = z
+  .enum(["pass", "dont-pass", "field"])
+  .describe("A craps bet: `pass`, `dont-pass`, or `field`.");
+export type CrapsBetType = z.infer<typeof CrapsBetType>;
+
+/** A craps bet input — the type and the stake. */
+export const CrapsBet = z
+  .object({ type: CrapsBetType.describe("Which bet."), amount: z.number().int().describe("The stake.") })
+  .describe("A craps bet.");
+export type CrapsBet = z.infer<typeof CrapsBet>;
+
+/** The craps round state — the come-out/point phase, the point, the shooter, and the last roll. */
+export const CrapsRound = z
+  .object({
+    phase: z.enum(["come-out", "point"]).describe("`come-out` (no point yet) or `point` (rolling to make the point)."),
+    point: z.number().int().nullable().describe("The established point (4,5,6,8,9,10), or null on the come-out."),
+    shooterIndex: z
+      .number()
+      .int()
+      .describe("Index into the roster of the current shooter — the only player who may roll."),
+    lastRoll: z
+      .tuple([z.number(), z.number()])
+      .nullable()
+      .describe("The two dice of the last roll, or null before the first."),
+  })
+  .describe("The craps round state.");
+export type CrapsRound = z.infer<typeof CrapsRound>;
+
+/** The field bet's one-roll outcome for a dice sum: a win multiplier (1 or 2), or null to lose. */
+function fieldWin(sum: number): number | null {
+  if (sum === 2 || sum === 12) return 2;
+  if (sum === 3 || sum === 4 || sum === 9 || sum === 10 || sum === 11) return 1;
+  return null; // 5,6,7,8 lose
+}
+
+/** Resolve a pass/don't-pass bet against a roll in a phase. win/lose/push, or null if it carries. */
+function passOutcome(
+  type: "pass" | "dont-pass",
+  phase: "come-out" | "point",
+  point: number | null,
+  sum: number,
+): "win" | "lose" | "push" | null {
+  if (phase === "come-out") {
+    if (sum === 7 || sum === 11) return type === "pass" ? "win" : "lose";
+    if (sum === 2 || sum === 3) return type === "pass" ? "lose" : "win";
+    if (sum === 12) return type === "pass" ? "lose" : "push";
+    return null; // point established; the bet carries
+  }
+  if (sum === point) return type === "pass" ? "win" : "lose";
+  if (sum === 7) return type === "pass" ? "lose" : "win"; // seven-out
+  return null; // no decision; the bet carries
+}
+
+export const crapsGame = wageringTable<CrapsConfig, CrapsRound, CrapsBet>({
+  kind: "craps",
+  config: CrapsConfig,
+  round: CrapsRound,
+  bet: CrapsBet,
+  minPlayers: 1,
+  currency: (config) => config.currency,
+
+  startRound: () => ({ phase: "come-out", point: null, shooterIndex: 0, lastRoll: null }),
+
+  placeBet(ctx, round, playerId, bet, bets) {
+    if (bet.amount < ctx.config.minBet || (ctx.config.maxBet !== undefined && bet.amount > ctx.config.maxBet)) {
+      throw new MultiplayerInvalidMoveError({
+        message: `Bet must be between ${ctx.config.minBet} and ${ctx.config.maxBet ?? "∞"}.`,
+        detail: `Bet ${bet.amount} outside limits.`,
+      });
+    }
+    if ((bet.type === "pass" || bet.type === "dont-pass") && round.phase !== "come-out") {
+      throw new MultiplayerInvalidTransitionError({
+        message: "Pass and don't-pass bets are only allowed on the come-out.",
+        detail: `Phase ${round.phase}.`,
+      });
+    }
+    if (bets.some((b) => b.userId === playerId && (b.data as { type: string }).type === bet.type)) {
+      throw new MultiplayerInvalidTransitionError({
+        message: `You already have a ${bet.type} bet pending.`,
+        detail: `Duplicate ${bet.type} for ${playerId}.`,
+      });
+    }
+    return { amount: bet.amount, data: { type: bet.type } };
+  },
+
+  // Only the shooter may roll. Clamp the index in case the roster shrank since it was set.
+  eventDriver: (ctx, round) => ctx.players[round.shooterIndex % Math.max(1, ctx.players.length)] ?? null,
+
+  runEvent(ctx, round, bets) {
+    const d1 = ctx.random.int(1, 6);
+    const d2 = ctx.random.int(1, 6);
+    const sum = d1 + d2;
+
+    const decisions: BetDecision[] = [];
+    for (const bet of bets) {
+      const type = (bet.data as { type: CrapsBetType }).type;
+      if (type === "field") {
+        const w = fieldWin(sum);
+        decisions.push({ ref: bet.ref, result: w === null ? "lose" : "win", payout: w === null ? 0 : bet.amount * w });
+      } else {
+        const result = passOutcome(type, round.phase, round.point, sum);
+        if (result !== null) decisions.push({ ref: bet.ref, result, payout: result === "win" ? bet.amount : 0 });
+        // null → the pass/don't-pass bet carries (no decision)
+      }
+    }
+
+    // Advance the round based on the pass-line outcome.
+    let phase = round.phase;
+    let point = round.point;
+    let shooterIndex = round.shooterIndex;
+    if (round.phase === "come-out") {
+      if (sum === 4 || sum === 5 || sum === 6 || sum === 8 || sum === 9 || sum === 10) {
+        phase = "point";
+        point = sum;
+      }
+    } else if (sum === point) {
+      phase = "come-out";
+      point = null; // point made — same shooter
+    } else if (sum === 7) {
+      phase = "come-out";
+      point = null;
+      shooterIndex = ctx.players.length > 0 ? (round.shooterIndex + 1) % ctx.players.length : 0; // seven-out passes the dice
+    }
+
+    return { round: { phase, point, shooterIndex, lastRoll: [d1, d2] as [number, number] }, decisions };
+  },
+
+  view: (ctx, round) => ({
+    phase: round.phase,
+    point: round.point,
+    shooter: ctx.players[round.shooterIndex % Math.max(1, ctx.players.length)] ?? null,
+    lastRoll: round.lastRoll,
+  }),
+});
+
+/** Re-exported so a caller (or a test) can reference a pending craps bet's shape. */
+export type { PendingBet as CrapsPendingBet };

package/src/game/model.ts

@@ -0,0 +1,154 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import type { z } from "zod";
+import type { LedgerEffect } from "./effects";
+import type { RandomSource } from "./random";
+
+/**
+ * The game-model seam — the one contract that keeps the session infrastructure generic.
+ *
+ * A `MultiplayerSession` Durable Object knows nothing about any particular game: membership, the lifecycle,
+ * hidden state, the alarm-driven deadline, the durable D1 result, the leaderboard publish, and the CLI DO
+ * wiring are all game-agnostic. Everything a specific game *is* — how a move validates, how state advances,
+ * when it ends, who wins, and what each player is allowed to see — lives behind a {@link GameModel}, looked
+ * up by `kind` from the {@link resolveModel registry}. The two built-ins ({@link commitRevealModel} and
+ * {@link sequentialModel}) are the two fundamental turn-based shapes — simultaneous and sequential — and an
+ * adopter registers their own with {@link registerGameModel}.
+ *
+ * The seam is code, not data: a model's *logic* is imported into the worker bundle, while only its *state*
+ * (a serializable, Zod-validated blob) lives in DO storage. That is what lets the DO — which is constructed
+ * by the runtime and cannot be handed a closure — delegate to a model it never imported directly.
+ */
+
+/** The resolved result of a game, in the model-neutral shape the session records and publishes. */
+export interface ModelOutcome {
+  /** Each player's final score, keyed by user id. */
+  scores: Record<string, number>;
+  /** The winning player's user id, or null on a draw. */
+  winnerUserId: string | null;
+  /** Whether the game ended level. */
+  draw: boolean;
+}
+
+/** What `apply` returns: the next state, and any ledger effects the DO should settle (a bet's hold). */
+export interface ApplyResult<State> {
+  /** The next game state. */
+  state: State;
+  /** Ledger operations this transition implies — placed a bet, settled a round. Omit for a game with no wagering. */
+  effects?: readonly LedgerEffect[];
+}
+
+/** Wrap a bare next-state as an {@link ApplyResult} — the shape a non-wagering model returns. */
+export function nextState<State>(state: State, effects?: readonly LedgerEffect[]): ApplyResult<State> {
+  return effects ? { state, effects } : { state };
+}
+
+/** What `resolve` returns: the final outcome, and any ledger effects the terminal result implies (payouts). */
+export interface ResolveResult {
+  /** The final outcome — scores, a winner, or a draw. */
+  outcome: ModelOutcome;
+  /** Ledger operations the result implies — capture losing stakes, pay the winner. Omit for a game with no wagering. */
+  effects?: readonly LedgerEffect[];
+}
+
+/** What a model gets on every call: its validated config, the roster in join/turn order, a clock, and RNG. */
+export interface GameContext<Config> {
+  /** The session's id (the DO id, hex). Use it to build stable, idempotent ledger-effect refs. */
+  sessionId: string;
+  /** The game's model-specific config (the `rules` block), already validated by {@link GameModel.config}. */
+  config: Config;
+  /** The session's members, in join order — also the turn order for sequential games. */
+  players: readonly string[];
+  /** The current time as ms-epoch, supplied by the DO (never read from a clock inside a model). */
+  now: number;
+  /**
+   * Server-authoritative, provably-fair randomness — the seeded stream the DO advances and persists. Draw
+   * from it only in `init` and `apply` (the transitions the DO commits); `resolve` and `redact` must stay
+   * pure, or a replay would diverge. A model with no chance (tic-tac-toe) simply never touches it.
+   */
+  random: RandomSource;
+}
+
+/**
+ * One game model — a pluggable implementation of a game's rules over the shared session lifecycle.
+ *
+ * `Config` is the model's declarative config (the game's `rules` block); `State` is the authoritative game
+ * state the DO persists between actions. Both are Zod-validated: `config` at assembly, `state` on every
+ * read from DO storage (defense in depth against a corrupt blob).
+ */
+export interface GameModel<Config = unknown, State = unknown> {
+  /** The discriminator that matches a game config's `kind`. Unique per registered model. */
+  kind: string;
+  /** Validates and types the game's model-specific `rules` block. */
+  config: z.ZodType<Config>;
+  /** Validates and types the persisted game state — round-tripped through DO storage. */
+  state: z.ZodType<State>;
+  /** The fewest players this model supports (roster size). Defaults to 2 when omitted. */
+  minPlayers?: number;
+  /** The most players this model supports, or undefined for no upper bound. */
+  maxPlayers?: number;
+  /** The initial game state, built when the roster fills and play begins. */
+  init(ctx: GameContext<Config>): State;
+  /**
+   * Validate and apply one player's action, returning the next state (and any ledger effects it implies —
+   * a placed bet's hold, a settled round's payouts). Throws a `PithyError` (`multiplayer/invalid_move` or
+   * `multiplayer/invalid_transition`) when the action is illegal. A rejected action — or one whose effects
+   * the ledger cannot settle (a hold a player cannot cover) — is never persisted. May return a bare `State`
+   * for a game with no wagering.
+   */
+  apply(ctx: GameContext<Config>, state: State, playerId: string, action: unknown): ApplyResult<State>;
+  /** Whether the game has reached a terminal position (all committed, someone won, the board is full…). */
+  isComplete(ctx: GameContext<Config>, state: State): boolean;
+  /**
+   * The outcome once {@link isComplete} holds — scores, a winner, or a draw — and any ledger effects the
+   * terminal result implies (final payouts).
+   */
+  resolve(ctx: GameContext<Config>, state: State): ResolveResult;
+  /**
+   * The model-specific view one player is allowed to see. This is the hidden-state boundary: redact an
+   * opponent's secret information here, and reveal it only when `revealed` is true (the session is
+   * terminal). A fully-open game (a visible board) returns the same view to everyone.
+   */
+  redact(ctx: GameContext<Config>, state: State, viewerId: string, revealed: boolean): unknown;
+  /**
+   * Table mode only: a player took a seat mid-session. Optional — react to the seating (a buy-in, dealing
+   * them in next round) and declare any ledger effects. `ctx.players` already includes the joiner. Omit for
+   * a match-mode game, or a table game that needs no per-join bookkeeping.
+   */
+  onJoin?(ctx: GameContext<Config>, state: State, playerId: string): ApplyResult<State>;
+  /**
+   * Table mode only: a player left their seat mid-session. Optional — settle them out (release their open
+   * holds, cash out) and declare ledger effects. `ctx.players` already excludes the leaver. Omit if leaving
+   * needs no bookkeeping.
+   */
+  onLeave?(ctx: GameContext<Config>, state: State, playerId: string): ApplyResult<State>;
+}
+
+/** The registry: game `kind` → its model. Populated with the built-ins and any {@link registerGameModel} adds. */
+const registry = new Map<string, GameModel>();
+
+/**
+ * Register a game model, making its `kind` resolvable by every session. Called at module load — the worker
+ * entry and the DO share one isolate, so a model registered when the worker imports is present by the time
+ * the DO handles a request. Re-registering the same `kind` replaces it (last write wins), which is what
+ * lets an adopter override a built-in.
+ */
+export function registerGameModel(model: GameModel): void {
+  registry.set(model.kind, model);
+}
+
+/** The model for a `kind`, or undefined if none is registered. */
+export function resolveModel(kind: string): GameModel | undefined {
+  return registry.get(kind);
+}
+
+/** Every registered model's `kind`, for config validation and error messages. */
+export function registeredKinds(): string[] {
+  return [...registry.keys()];
+}
+
+/** The fewest / most players a model allows, with the shared default of 2 and no upper bound. */
+export function playerBounds(model: GameModel): { min: number; max: number } {
+  return { min: model.minPlayers ?? 2, max: model.maxPlayers ?? Number.POSITIVE_INFINITY };
+}

package/src/game/patterns/simultaneous.ts

@@ -0,0 +1,98 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import { z } from "zod";
+import { MultiplayerInvalidTransitionError } from "../../error/errors";
+import type { GameContext, GameModel, ModelOutcome, ResolveResult } from "../model";
+
+/**
+ * The **simultaneous** pattern — the base helper for games where every player submits a hidden choice at
+ * the same time and the server resolves them together once all are in. Rock-paper-scissors, a sealed-bid
+ * auction, a battle of secret moves, a hidden vote.
+ *
+ * It is "simultaneous" in the game-theory sense (players choose without seeing each other), enforced by a
+ * *trusted server* holding the plaintext submissions until everyone has committed — which is the model this
+ * package provides. (It is not a cryptographic commit-reveal protocol; a trustless hash-commit-then-reveal
+ * scheme would be a separate variant.)
+ *
+ * A game built on this helper supplies only what is game-specific: the shape of a submission, any extra
+ * validation, and how to score all submissions. The helper owns the lifecycle — collect one submission per
+ * player, reject a second, resolve when the last lands — and the hidden-state boundary (your own submission
+ * is visible; everyone else's is hidden until the game is terminal).
+ */
+export interface SimultaneousSpec<Config, Submission> {
+  /** The game's `kind` — its registry key. */
+  kind: string;
+  /** The game's config schema (the `rules` block). */
+  config: z.ZodType<Config>;
+  /** The schema for one player's hidden submission — the body of their action. */
+  submission: z.ZodType<Submission>;
+  /** The fewest / most players (defaults to 2 / no cap). */
+  minPlayers?: number;
+  maxPlayers?: number;
+  /** Extra validation of a submission beyond its schema (e.g. "exactly 3 distinct moves"). Throw a `PithyError`. */
+  validate?: (config: Config, submission: Submission, ctx: GameContext<Config>) => void;
+  /** Resolve every player's submission into an outcome (and optional ledger effects) once all have submitted. */
+  score: (ctx: GameContext<Config>, submissions: Record<string, Submission>) => ResolveResult | ModelOutcome;
+}
+
+/** The persisted state of a simultaneous game: each player's hidden submission, keyed by user id. */
+type SimultaneousState<Submission> = { submissions: Record<string, Submission> };
+
+/** Build a {@link GameModel} for a simultaneous game from its {@link SimultaneousSpec}. */
+export function simultaneous<Config, Submission>(
+  spec: SimultaneousSpec<Config, Submission>,
+): GameModel<Config, SimultaneousState<Submission>> {
+  const state = z
+    .object({
+      submissions: z.record(z.string(), spec.submission).describe("Each player's hidden submission, keyed by user id."),
+    })
+    .describe(`The ${spec.kind} game's persisted submissions.`);
+
+  return {
+    kind: spec.kind,
+    config: spec.config,
+    state,
+    minPlayers: spec.minPlayers,
+    maxPlayers: spec.maxPlayers,
+
+    init: () => ({ submissions: {} }),
+
+    apply(ctx, current, playerId, action) {
+      if (current.submissions[playerId] !== undefined) {
+        throw new MultiplayerInvalidTransitionError({
+          message: "You have already submitted.",
+          detail: `${playerId} already submitted in ${spec.kind}.`,
+        });
+      }
+      const submission = spec.submission.parse(action);
+      spec.validate?.(ctx.config, submission, ctx);
+      return { state: { submissions: { ...current.submissions, [playerId]: submission } } };
+    },
+
+    isComplete: (ctx, current) => ctx.players.every((player) => current.submissions[player] !== undefined),
+
+    resolve(ctx, current) {
+      const result = spec.score(ctx, current.submissions);
+      return "outcome" in result ? result : { outcome: result };
+    },
+
+    // The hidden-state boundary: your submission is always visible; opponents' are hidden until the reveal.
+    redact(ctx, current, viewerId, revealed) {
+      return {
+        you: {
+          userId: viewerId,
+          submitted: current.submissions[viewerId] !== undefined,
+          submission: current.submissions[viewerId] ?? null,
+        },
+        opponents: ctx.players
+          .filter((member) => member !== viewerId)
+          .map((member) => ({
+            userId: member,
+            submitted: current.submissions[member] !== undefined,
+            submission: revealed ? (current.submissions[member] ?? null) : null,
+          })),
+      };
+    },
+  };
+}

package/src/game/patterns/turnBased.ts

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import { z } from "zod";
+import { MultiplayerInvalidTransitionError } from "../../error/errors";
+import type { LedgerEffect } from "../effects";
+import type { GameContext, GameModel, ModelOutcome, ResolveResult } from "../model";
+
+/**
+ * The **turn-based** pattern — the base helper for games where players act one at a time, in order, against
+ * a shared state. Tic-tac-toe, Connect Four, chess, checkers, a card game's tricks.
+ *
+ * The helper owns turn order and advancement: it tracks whose turn it is, rejects a move out of turn, and
+ * rotates to the next player after each move. A game built on it supplies only the game-specific parts — the
+ * shared state, how a move changes it, when the game ends, and who won. The turn plumbing is not the game's
+ * to write.
+ */
+export interface TurnBasedSpec<Config, Game, Move> {
+  /** The game's `kind` — its registry key. */
+  kind: string;
+  /** The game's config schema (the `rules` block). */
+  config: z.ZodType<Config>;
+  /** The schema for the game-specific shared state (turn tracking is the helper's, not this). */
+  game: z.ZodType<Game>;
+  /** The schema for one move (the body of a player's action). */
+  move: z.ZodType<Move>;
+  /** The fewest / most players (defaults to 2 / no cap). */
+  minPlayers?: number;
+  maxPlayers?: number;
+  /** The initial game state when play begins. */
+  start: (ctx: GameContext<Config>) => Game;
+  /** Apply the current player's validated move, returning the next game state (+ optional ledger effects). Throw a `PithyError` on an illegal move. */
+  play: (
+    ctx: GameContext<Config>,
+    game: Game,
+    playerId: string,
+    move: Move,
+  ) => { game: Game; effects?: readonly LedgerEffect[] } | Game;
+  /** Whether the game has ended (someone won, the board is full…). */
+  isEnd: (ctx: GameContext<Config>, game: Game) => boolean;
+  /** The outcome once {@link isEnd} holds. */
+  score: (ctx: GameContext<Config>, game: Game) => ResolveResult | ModelOutcome;
+  /** Optional game-specific view; the helper adds the turn info around it. Defaults to the raw game state. */
+  view?: (ctx: GameContext<Config>, game: Game, viewerId: string) => unknown;
+}
+
+/** The persisted state of a turn-based game: whose turn (as a roster index) and the game-specific state. */
+type TurnBasedState<Game> = { turnIndex: number; game: Game };
+
+/** Build a {@link GameModel} for a turn-based game from its {@link TurnBasedSpec}. */
+export function turnBased<Config, Game, Move>(
+  spec: TurnBasedSpec<Config, Game, Move>,
+): GameModel<Config, TurnBasedState<Game>> {
+  const state = z
+    .object({
+      turnIndex: z.number().int().describe("Index into the roster of whose turn it is."),
+      game: spec.game.describe("The game-specific shared state."),
+    })
+    .describe(`The ${spec.kind} game's state — the turn pointer and the shared position.`);
+
+  return {
+    kind: spec.kind,
+    config: spec.config,
+    state,
+    minPlayers: spec.minPlayers,
+    maxPlayers: spec.maxPlayers,
+
+    init: (ctx) => ({ turnIndex: 0, game: spec.start(ctx) }),
+
+    apply(ctx, current, playerId, action) {
+      if (playerId !== ctx.players[current.turnIndex]) {
+        throw new MultiplayerInvalidTransitionError({
+          message: "It is not your turn.",
+          detail: `${playerId} moved out of turn (turn is ${ctx.players[current.turnIndex]}).`,
+        });
+      }
+      const move = spec.move.parse(action);
+      const played = spec.play(ctx, current.game, playerId, move);
+      const game = played !== null && typeof played === "object" && "game" in played ? played.game : (played as Game);
+      const effects = played !== null && typeof played === "object" && "effects" in played ? played.effects : undefined;
+      const turnIndex = (current.turnIndex + 1) % ctx.players.length;
+      return { state: { turnIndex, game }, effects };
+    },
+
+    isComplete: (ctx, current) => spec.isEnd(ctx, current.game),
+
+    resolve(ctx, current) {
+      const result = spec.score(ctx, current.game);
+      return "outcome" in result ? result : { outcome: result };
+    },
+
+    redact(ctx, current, viewerId) {
+      const turn = ctx.players[current.turnIndex] ?? null;
+      return {
+        turn,
+        yourTurn: turn === viewerId,
+        ...(spec.view ? { game: spec.view(ctx, current.game, viewerId) } : { game: current.game }),
+      };
+    },
+  };
+}