At this level
games.cavu · 16- games.cavu.addon record Content a player made for a game, such as a Tier Madness category or criterion. It lives in its author's repo; the game uses it only once the game's publisher approves it (a games.cavu.approval whose subject is this record's exact version, so an edit needs approving again). rkey MUST be '<game>:<id>' (a TID); readers reject records whose rkey doesn't start with their own `game`.
- games.cavu.authPlay permission-set
- games.cavu.bindSession procedure Served by the game host named in a grant's hostService. The game server presents the grant and its attestation with a DPoP proof (DPoP header, ES256). The host verifies the attestation against the launch service's key, checks the grant is unexpired and names this host, checks `jkt` matches the proof key, consumes the nonce (which it minted for `player`), and binds a session to that key. Later calls (getCapabilities, com.atproto.repo.putRecord, ...) carry `Authorization: DPoP <session>` plus a fr
- games.cavu.clientFrame object Frames a client sends up the games.cavu.subscribeSession socket (DAG-CBOR event-stream framing: header {op:1, t:'#join'|'#intent'|'#ping'} + body).
- games.cavu.codex record A card in a game's world: an item (a program, a weapon), an encounter (a piece of ICE, a monster, a trap), a character or a place. One record per card, not a player's copy of one: a player owns an item as an equipment.rpg.item whose `give` is this record's URI and whose stats carry a strongRef to it. It lives in the repo of the player whose play made it, signed by the game service so its stats can be trusted. rkey MUST be '<game>:<id>' (a TID); readers reject records whose rkey doesn't start wit
- games.cavu.defs defs badge.blue CID-first attestation over the grant: DAG-CBOR(grant) -> SHA-256 -> CIDv1(dag-cbor), signed with low-S ECDSA by the key `key` (a DID URL resolving to a verification method in the launch service's DID document).
- games.cavu.entityClass record An entity class to share between games: a Lua script returning the class table (handlers, project, view, synced, ...), run sandboxed by the Cavu entity engine. A game lists it in its manifest under `classes` by the name it gives it ("walker": "at://did/games.cavu.entityClass/rkey"), and its own classes may extend it by that name.
- games.cavu.game record Cavu's sidecar to a game's games.atmosphere.define record: how the game launches and what it may do with a player's account. Same rkey as the define record: the game's slug (e.g. 'haiku-day'), which scopes everything the game may write (games.cavu.score / games.cavu.save at '<slug>[:...]', actor.rpg.stats at '<slug>'). The game's name, description, art and links live in the define record.
- games.cavu.getCapabilities query What this bound session may do, as resolved by the host (standard sets expanded to the concrete collections/rkeys for this game). Requires the session token and a DPoP proof.
- games.cavu.haikuDay defs Haiku Day's types: scoreDetails ($type of a games.cavu.score record's details for game haiku-day) and the intents and views it exchanges over games.cavu.subscribeSession.
- games.cavu.launchIntent procedure Ask a game's launch service for a signed launch grant. Called by the launcher (e.g. cavu.games) against the service named in the launch service's DID document. The service picks the room and the instance that owns it and returns their URL inside the signed grant.
- games.cavu.pack record One version of a game's code and assets: every file the game runs (its manifest.json, Lua modules, data files, assets/ and og.png), each a blob. A pack is never edited: a new version is a new record, and it goes live when the game's games.cavu.game record (same repo) points `pack` at it, so rolling back is pointing it at an older one. Game servers fetch the pack and check every blob against its CID.
- games.cavu.save record Progress / save state a game resumes from. rkey MUST be '<game>' or '<game>:<slot>'.
- games.cavu.score record One result for one game and period. rkey MUST be '<game>:<period>' (e.g. 'haiku-day:2026-10-06'); readers reject records whose rkey doesn't match their own `game` and `period`.
- games.cavu.secret record A game's server secret. Lives in the publisher's own repo inside the game's private memberspace (at://<publisher>/space/games.cavu.secrets/<slug>), never in the public repo; only services that are members of that space (the game servers that run it) can read it. Games never see it: they get values mixed from it with ctx.seed(label). Replacing it changes everything mixed from it (e.g. a daily deal).
- games.cavu.subscribeSession subscription Bidirectional game session. Server->client messages are below; client->server frames are games.cavu.clientFrame.
- games.cavu.tier-madness.clientFrame object Frames a client sends up the games.cavu.tier-madness.subscribeGame socket. Intents only: the server validates each, records it in the player's own PDS (secret move + public commitment), and only then applies it.
- games.cavu.tier-madness.commitSpace space A Tier Madness game's shared table (one space per game, keyed by the game's TID): each move's commitment, the host's game record, and everyone's round records. Readable by the game's players.
- games.cavu.tier-madness.commitment record Public commitment to a secret games.cavu.tier-madness.move, written to the game's commitment space (readable by the game's players) under the same rkey as the move. Anyone can later check a revealed move hashes to this CID.
- games.cavu.tier-madness.defs defs An end-of-game superlative and the bonus points it paid.
- games.cavu.tier-madness.game record Declares a game: the roster in seat order and the ballot. Written by the host player, from their own PDS, to the game's commitment space (rkey = game id). With each player's round records and moves it is enough to replay the game: replay checks every player's records agree.
- games.cavu.tier-madness.lobby record Announces that a game exists and is taking players. Written by the host, from their own PDS, to their public repo (rkey = game id). Players join by giving the game server the game's 4-character code; the code itself is never published. codeHash is an HMAC of the code under the space host's secret key: unkeyed, all ~1M codes could be hashed in about a second. The server indexes lobbies by codeHash and hashes the code a player gives it.
- games.cavu.tier-madness.move record One secret move by a player, written (by the game server, on the player's behalf, or by the player) to the round's secret space (skey `{game}-r{round}`). Only the game server can read it until that round's reveal, when the game's players can too (round 0, the category vote, opens at game end). Its CID is published as a games.cavu.tier-madness.commitment (same rkey) in the game's commitment space, so the move can't be changed later. The nonce stops anyone from guessing a low-entropy move (e.g. a
- games.cavu.tier-madness.player record A player's Tier Madness profile, in their public repo.
- games.cavu.tier-madness.round record One player's account of a finished round, written by every player from their own PDS to the game's commitment space (rkey = `{game}-r{round}`) once the round's reveal starts. Written at the end rather than the start so it can't leak the deal order. Replay checks every player's round records agree.
- games.cavu.tier-madness.secretSpace space One player's secret moves for one round of a Tier Madness game (one space per round, keyed {game}-r{round}). Only the player can read it until the game server opens the round at its reveal.
- games.cavu.tier-madness.subscribeGame subscription A game's live channel. The socket is bidirectional: the client sends games.cavu.tier-madness.clientFrame frames (#auth then #create/#join to play, or just #spectate to watch); the server sends a #snapshot of the game as that viewer may see it whenever it changes.