A seat lived in the browser's storage alone, and Safari clears that after a week away, or at a word from the person on another device. Now every seat taken is banked as well in an HttpOnly cookie the server writes, which such clearing leaves alone, and the hall takes its seats back from the bank on arrival. For a browser that lost even the cookie, the ledger notes the address each seat was last used from, as a salted hash, and a name given in the hall or at the table gets its seats back from the same address, with a new token; where the address differs, two people at the table share it, or the host gave the seat to a bot, the table is only counted, and the host's phrase or the keeper's link is the way back. The keeper's script finds a name across tables. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CCLa2PaEeCj8njQZSWGqHx
92 lines
4.2 KiB
TypeScript
92 lines
4.2 KiB
TypeScript
// One append-only JSONL file per room. A room is its ledger replayed from the
|
|
// top: the engine is deterministic given the seed and the recorded inputs, so
|
|
// nothing else needs saving.
|
|
|
|
import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import type { SeatId, TableOptions } from '../../src/lib/game/spec';
|
|
|
|
export type LedgerLine =
|
|
/** `rematchOf` and `expected` mark a table opened for a rematch: whose it follows, and whose seats are held. */
|
|
| { t: 'room'; id: string; seats: number; createdAt: number; rematchOf?: string; expected?: string[]; options: TableOptions }
|
|
/** A seat holds only the hash of its token; the token itself goes once to the browser that earned it. A bot's hash is empty. */
|
|
| { t: 'seat'; id: SeatId; name: string; tokenHash: string; bot: boolean }
|
|
/**
|
|
* A person's seat got a new token, from the keeper or a phrase the host made, for a player whose browser lost the
|
|
* old one; the old one opens nothing after. A seat a bot was standing in for is the person's again.
|
|
*/
|
|
| { t: 'reseat'; at: number; id: SeatId; tokenHash: string }
|
|
/** The host gave a person's seat to a bot, which plays it from here on; a reseat gives it back. */
|
|
| { t: 'standIn'; at: number; id: SeatId; by: SeatId }
|
|
/** One seat's move for the round in progress, so a restart keeps it. The turn line that follows carries every input again. */
|
|
| { t: 'input'; at: number; id: SeatId; input: unknown }
|
|
/** A bot sent away by the host before the game began; its seat id is free again. */
|
|
| { t: 'unseat'; id: SeatId }
|
|
/** A seat's ranking of the table's choices, best first, before the game begins; the latest for a seat stands. */
|
|
| { t: 'rank'; id: SeatId; ranking: string[] }
|
|
/**
|
|
* The seed and the rules revision the game began under (a later fix keeps
|
|
* this revision's path for it), and at a table that asks for rankings,
|
|
* the seats' rankings as the deal read them.
|
|
*/
|
|
| { t: 'start'; seed: number; rules: number; rankings?: Record<SeatId, string[]> }
|
|
| { t: 'turn'; at: number; inputs: Record<SeatId, unknown> }
|
|
/** Written after the turn that ends the game, for anything that reads ledgers without the engine. */
|
|
| { t: 'over'; at: number; winner: SeatId | null; reason: string }
|
|
/**
|
|
* A line of table talk: from a seat, or, with `name`, from the Peanut Gallery (id SPECTATOR).
|
|
* `to` names the seats a private line was said to; `note` is a bot's memory of what it said, never shown.
|
|
*/
|
|
| { t: 'chat'; at: number; id: SeatId; text: string; name?: string; keeper?: true; to?: SeatId[]; note?: unknown }
|
|
/** The host let the gallery talk, or hushed it. */
|
|
| { t: 'galleryTalk'; at: number; on: boolean; by: SeatId }
|
|
/** A seat is held for the keeper of the site, called to the table. */
|
|
| { t: 'challenge'; at: number; by: SeatId; keeper: string }
|
|
/** A finished table called for a rematch: where it went, and who called. */
|
|
| { t: 'rematch'; at: number; to: string; by: SeatId }
|
|
/** The address a person's seat was last used from, as a salted hash, so a seat a browser lost can go back to the same address. */
|
|
| { t: 'seen'; at: number; id: SeatId; addr: string };
|
|
|
|
export class Store {
|
|
constructor(private dir: string) {
|
|
mkdirSync(dir, { recursive: true });
|
|
}
|
|
|
|
private path(roomId: string): string {
|
|
return join(this.dir, `${roomId}.jsonl`);
|
|
}
|
|
|
|
append(roomId: string, line: LedgerLine): void {
|
|
appendFileSync(this.path(roomId), JSON.stringify(line) + '\n');
|
|
}
|
|
|
|
read(roomId: string): LedgerLine[] {
|
|
const path = this.path(roomId);
|
|
if (!existsSync(path)) return [];
|
|
return readFileSync(path, 'utf8')
|
|
.split('\n')
|
|
.filter((l) => l.trim())
|
|
.map((l) => JSON.parse(l) as LedgerLine);
|
|
}
|
|
|
|
/** Whether a ledger exists on disk, loaded or not; a code must not be reissued over one. */
|
|
exists(roomId: string): boolean {
|
|
return existsSync(this.path(roomId));
|
|
}
|
|
|
|
/** When the ledger was last written, for passing over tables long finished. */
|
|
updatedAt(roomId: string): number {
|
|
try {
|
|
return statSync(this.path(roomId)).mtimeMs;
|
|
} catch {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
roomIds(): string[] {
|
|
return readdirSync(this.dir)
|
|
.filter((f) => f.endsWith('.jsonl'))
|
|
.map((f) => f.slice(0, -'.jsonl'.length));
|
|
}
|
|
}
|