The Village Hall

The organizer's phone makes itself the one writer. Every other phone connects to it over iroh, which dials a phone by its public key rather than its address: there is no server in the middle, and the code a phone scans says how to find the organizer.

The handshake is a QR code on the organizer's screen: how to reach it, its public key — which also authenticates and encrypts the link — and invitations good for a single connection each. That is the whole of what one phone needs to know about another.

Once a phone is through the door it receives the entire history from entry zero, and arrives current without replaying a decision of its own. It does not recompute the evening. It receives it.

That pass is for the phones that work the evening: selling cards at the door or calling the balls. A player joins with the code the seller shows at the sale — one link that opens the app, or the same screen in a browser when the app is not installed — and gets something different: not the history, but each ball as it comes out.

“cloud and microservice ecosystems become libraries the program invokes rather than habitats the program inhabits”

Paper 07 · After the Substrate

Every phone in the room keeps its own journal, and a journal is a directory in the application's private storage. There is no schema to migrate, no connection string, no engine to install and nothing to be reachable.

This is what makes the operational questions collapse into one another. Backing up the evening is copying the folder. Handing it to another phone is sending the same entries. Coming back after the signal dropped is replaying what arrived late.

And the journal is small, because of what it records: each operation by name, not the state it left behind. In Puppeteer's published laboratories an entry encodes to between 33 and 96.7 bytes, where the same operation written out in full takes 118 to 910.7 — and compressing the written-out form afterwards closes the gap only to fourfold, because the saving is in how the operation is named rather than in how the bytes are packed. A night of bingo is a small file.

The number printed on a card is not a key into a table of cards. It is the card: twenty-four numbers fall out of it by a keyed hash, the same way on every phone, so a phone that has never heard of that card draws it correctly the moment it has the number.

So a card is never transmitted, stored or synchronized. A player's phone is told which numbers they bought — which cards are whose was written when the sale happened — and rebuilds the cards from them.

Cardface Of(CardNumber number)
    stream  = HMACSHA256("bingo75.cardface.v1", number)
    columns = five bands drawn from that stream

When a ball is called, no phone receives a board. Each one receives the fact that a ball came out, and applies it to its own journal — the same operation the organizer performed, performed again locally.

A phone that closes and reopens presents itself again, and the answer carries every ball it missed; what it had already marked was never only in memory. And a ball carries the round it belongs to: keying the wrong number twice in one evening is two corrections, not a repetition of the first.

ListenAs(role)
    .Told("Ball").With<int>("number")
        .Command("game.RegisterDraw(@number);")
    .Told("Correction").With<int>("wrong").With<int>("right")
        .Command("game.CorrectDraw(@wrong, @right);")

“Recording cross-actor messages as program operations preserves continuity edge by edge, without orchestration.”

Paper 04 · Preserving Semantic Continuity Across Actors