// 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 } | { t: 'turn'; at: number; inputs: Record } /** 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)); } }